Find Your Mac's Serial Number
Want to check your Mac's serial number quickly and easily? Select About This Mac from the Apple menu, and click on the text directly below "Mac OS X" that reads "Version 10.x.x." Click once and you'll get a build number which is more specific information about the software. Click twice, and you'll get your Mac's serial number.
Visit MacTipster Blog
Series: Conquer Your Text
TidBITS examines information storage and retrieval utilities
Article 1 of 21 in series
by Matt Neuburg
While reviewing Inspiration 4.0 for TidBITS #180, I meant to compare it as an outliner with Acta, but the winner kept turning out to be MORE, which I had never meant to consider seriously, and of which I had only an outmoded version (2.0) to examineShow full article
While reviewing Inspiration 4.0 for TidBITS #180, I meant to compare it as an outliner with Acta, but the winner kept turning out to be MORE, which I had never meant to consider seriously, and of which I had only an outmoded version (2.0) to examine. So I took a closer look, and for two months now, I have used the latest version, MORE 3.1, on a daily basis.
I liken MORE to a dinosaur in the best and worst senses. MORE started life as ThinkTank, the magnificent brainchild of Dave Winer, back in the Apple II days. As the Mac came to life, Winer evolved ThinkTank into MORE 1.0. Like dinosaurs, ThinkTank and MORE were vastly successful because they were the best at what they did. If you want to use an outliner as a serious writing tool, MORE remains the only way to go.
But after a Cretaceous heyday, dinosaurs had to adapt or die. Symantec bought out Winer (leaving him free to play God in the brave new world of scripting, with Frontier), and was a good deity stand-in for a couple of eras; but lately its attention has strayed, and MORE is showing signs of being too big and clunky and failing to keep up with the environment. If Symantec doesn't take it seriously again, or sell it to someone who will, it could easily go extinct. This would be a terrible loss.
The Milieu -- An outliner, you recall, works with text (and, in MORE and some other outliners, imported graphics) as topics. Every topic is subordinate to (is a subtopic of) some other topic, up to the main topic (or title) of the whole outline; an immediate subtopic of a topic is said to be one level deeper than that topic. The advantage of this organization lies in how you can view and rearrange topics. Any topic can have its subtopics either collapsed, so that they are invisible, or expanded, so that they appear below and indented relative to the topic. If you cut a topic, its subtopics (and their subtopics, and so on), whether visible or not, are cut as well; likewise, if you move a topic (by cut & paste or by dragging), its subtopics travel with it. This hierarchical structure for storing, viewing, and rearranging clumps of material is indispensable to me for creative work (preparing articles and lectures) and for reference (notes on books).
MORE (like most outliners) also lets you fold a topic, meaning simply that when the topic is visible, only its first line actually shows. This helps with viewing and navigation if topics become lengthy.
Some outliners, MORE included, provide a second entity, usually called paragraphs or notes. Only one note can attach to a given topic, and it can be shown or hidden independent of whether the topic's subtopics are collapsed or expanded. A frequent use of this feature is to make topics be subject headings only, with the actual discussion confined to notes. You aren't compelled to do this - in the old Apple II ThinkTank, you were, since topics were confined to 80 characters, whereas now a MORE topic (or note) can be as long as you like - but maintaining the distinction often helps clarity and flexibility.
[By the way, I'm not using the MORE documentation terminology. They call topics "headlines" and notes "comments."]
So much for the basic features that make an outliner an outliner. The devil, however, is in the details. MOREphistopheles comes into its own in the details.
Navigation -- A major MORE advantage is that it implements text navigation like a true word processor. Most outliners use or emulate Apple's built-in TextEdit routines (as exemplified by TeachText), which are primitive, to put it nicely. But MORE gives you text-navigation power nearer the level of Word or Nisus. Double-click to a select a word, triple-click to select a sentence. Up- and down-arrow keys move by line; right- and left-arrow keys move by letter, adding Command moves by word, adding Option moves to the start or end of the topic (or note); and Shift can be added to any of these to select text.
Remarkably, such text navigation melds into topic navigation. Other outliners treat topics as isolated units. In Acta, for example, repeating the left-arrow key in a topic moves through the topic but stops at the first letter; but in MORE, when the start of the current topic is reached, the insertion point just moves on up to the end of the previous visible topic. (Of course you can't do this while selecting; a selection cannot consist of text split between topics, as this would make hash of the notion of a topic.)
Similarly, other outliners make much of the distinction of whether you are in a topic (you have selected its text) or about a topic (you have selected the topic as an entity). Of course this distinction exists, but MORE lets it break down where convenient. In Inspiration, if the insertion point is within the text of a topic, you can delete text, but not the topic itself; you need to use the mouse, so that the topic itself is selected, before you can delete it. In MORE, with the insertion point in a topic, if any text is selected, hitting Clear deletes the text, but otherwise it deletes the topic; hitting Delete deletes the selected text or previous letter, but if you're at the start of a topic, it deletes the topic barrier itself, merging the topic into the previous one.
Keyboard navigation between topics is similarly easy and powerful. Command-up- or down-arrow moves into the previous or next currently visible topic; option-left-arrow moves to the topic governing the present topic; option-right-arrow moves to the present topic's last subtopic. Similarly, keyboard shortcuts let you show or hide notes, fold or unfold topics, expand or collapse subtopics. I hate leaving the keyboard to use the mouse, so I appreciate MORE's full set of keyboard shortcuts, which is matched by no other outliner.
And if you do choose to use the mouse, the way you use it is great. In most other outliners, you must use the mouse very precisely, to put the selection point right into a topic, or click right on the topic's "marker" to select the whole topic; with MORE, clicking anywhere to the right or left of a topic lets you select the topic, expand or collapse it (by double-clicking), fold or unfold it (by option-double-clicking). Almost the only time you have to aim precisely is if you elect to use the mouse rather than keys to show or hide a topic's note.
The way MORE implements notes deserves commendation. A note appears, when made visible, as a scrolling window within the main window, below its topic; subsequent topics move down to accommodate it. Moreover, this window can be resized. If you click outside a note window, it remains, but its scrollbars turn inactive. The result is smooth, clean, and convenient, and not at all buggy, unlike other implementations of notes within outlines.
Another nice feature is hoisting. To hoist something is to focus in on it, removing other material from view. If you hoist a topic, it shows as the first topic (top-left) in the window (in this view you can work with the topic's subtopics and create new ones, but you can't make a new topic at the same level). If you hoist a note, it fills the main window.
Reorganisation -- When you want to reorganise your outline, MORE provides just about every imaginable tool for doing so. To move a topic, you can cut & paste, or drag, or use keyboard shortcuts to move it a single increment up or down, or deeper or shallower. Keyboard commands also can promote all of a topic's immediate subtopics to its level, or demote a topic's co-topics to become its subtopics. You can split a topic into two at the insertion point within it; and you can even merge two topics into one (unlike any other outliner I know).
Especially interesting is MORE's capability to clone a topic. This is like an internal, mutual publish & subscribe: if two or more topics are clones of each other, any change made to the text of any of them, or to the text or organization of their subtopics, is instantly reflected in all of them. (Don't worry, if you delete a clone topic, its clones are not deleted!) Also, if a clone is selected there is a command to take you to its next clone. I find this valuable for creating multiple "views" of data within the same document. For example, I summarise a book from start to finish; beneath that I create subject topics and bring together, as their subtopics, clones of the relevant topics from the summary. Now I've got two views of the same material; if I make a wording change in one view, it's reflected in the other; and it's easy to flip from material in the summary view to the same material in the subject view.
You can select multiple topics: it's easy to select contiguous or non-contiguous topics one by one; or, with modifier-clicks, all a topic's subtopics, co-topics, or topics on the same level whether they are subordinate to the same topic or not; or, from the menu, all topics at a given level or range of levels. Once you've done this, you can print or export just the selected topics, or even format the selected topics. You can also clone, copy, or cut & paste all the selected topics so that they come together under one topic.
Rulers and Formatting -- MORE's formatting capabilities set it apart from all other outliners. Formatting rules are contained in rulers, rather like those of Nisus: initially there is one ruler, attached to the title topic, but you can add a ruler to any topic; a ruler governs the formatting for its topic and all subtopics, infinitely deep or until another ruler is encountered. Rulers can be copied, cut, and pasted; they can be transferred between documents, and even named and stored in a library. A menu command opens a window in which you can set or modify the formatting rules for the ruler attached to the current topic. These formatting rules govern just about every imaginable aspect of the document's appearance: not just character formatting such as default font, size, style, and color, but also paragraph formatting such as justification (left, right, centered, or full), margins and paragraph indent, tabs, and line spacing, and even outline formatting such as topic labels and spacing between topics. Paragraph margins can be set relative to the page margins or to those of the governing topic. So every topic is a kind of paragraph (or collection of paragraphs), making MORE not a mere outliner, but a word processor which "does" outlines (superbly).
That's not all. Every formatting rule has a scope: it applies to topics or notes or both, at a set range of levels of subordination starting with the topic to which the ruler is attached. This means you can have multiple formatting rules within a ruler, dealing with the same subject: for example, this topic should be bold, its subtopics should be italic, and their subtopics down to infinity should be plain.
You aren't confined to using the ruler rules for formatting either. Character formatting can be set from the menus; paragraph formatting can be set from a Word-style ruler at the top of the window. Combine all this with MORE's powerful printing options - set page margins, create headers and footers, print all or all visible or all selected topics, set range of levels of topics and notes to print - and what you have is the ability to prepare a polished presentable printed document from entirely within the outliner. I know no other outliner that lets you do this.
A Case of the Clunkies -- There are many things I would change to improve the interface to give MORE a stronger market position. I have no idea whether these or any changes will ever take place. The creation date for MORE 3.1 is December 1991; the Mac world has changed radically since then, but all one hears about MORE are rumours (unconfirmed) that Symantec is ready to abandon the program. Here, then, is a wish list that may be utterly in vain.
First, some of the editing and interface details could use improvement:
When you create a new topic MORE automatically places it just below the present topic. If this isn't where you wanted it, you have to move it. This is silly. Even Acta lets you make a new topic be a co-topic, subtopic, or co-topic of the governing topic at the instant of creation.
When moving a topic by dragging, it isn't clear where it's going to be put when you release the mouse. Acta shows an outline of the topic as you drag, so you know just where it will go.
There is no facility to select by paragraph, and no formatting rule to dictate the spacing between paragraphs. There is no keyboard command letting you move the insertion point sentence by sentence. There is no way to keyboard-navigate out of a note; you must either hide the note or use the mouse. There is no quick way to turn a note into a topic or vice-versa.
Most distressing, MORE forgets certain crucial viewing information. You can resize a notes window, but if you hide the note and then show it again, MORE assigns its window a new size. Even worse, if you collapse a topic and then expand it, you can only expand either to just its immediate subtopics or else to infinity; MORE has forgotten the expansion state of the individual subtopics. Acta distinguishes between collapsing so that the current state of all subtopics is remembered, and full collapsing so that all subtopics are also collapsed.
So much for editing and interface. Now, more general comments. MORE is System 7-compatible, but no more. At the very least it wants Publish & Subscribe, so that a topic from one outline can show up in another. (Of the outliners I know, only Acta 7 has decent Publish & Subscribe.)
MORE has extensive import/export capabilities, and does a remarkably good job of maintaining formatting information. But it uses proprietary translation modules, so you're limited to what it includes. Either it should include more (Acta? Nisus? RTF?) or it should support XTND technology. It also lacks the ability (which ThinkTank had) to export just the notes.
The manual (in six volumes) is huge, daunting, turgid, dull, confusing, uninformative, and inaccurate. It looks and reads like the Think C manual. A simple, stupendously unbelievable example: the "Quick Reference" is arranged by action - for example, it tells you what will happen if you press Enter, or if you option-double-click to the right of a topic. But I can find that out by doing it. I consult the Quick Reference because I want to know how to achieve some desired result; so it should be arranged by result ("To fold a topic..."; "To show a topic's note..."). The Online Help is even worse; I couldn't even find out from it how to create a new topic!
MORE itself is too "big". I'm not saying that spell-checking, GREP-searching, summing, phone dialing, calendars, drawing tools, and a 144K graphing utility aren't nice, but they do make me wonder whether anyone in charge has a vision of what this program is supposed to do that doesn't involve the words "kitchen sink." I have not even mentioned MORE's Bullet chart and a Tree chart view of the outline, intended so you (the business type) can make diagrams and slide presentations. Because of all this, MORE costs too much. IN CONTROL is moving high volume with a street price of $85 and a variety of give-away packages; MORE's size, its battery of features, and its street price of about $260 add up to Pure Stodge.
Here's my strategy in a nutshell. Now that System 7 is here with IAC and the rest of it, bust up MORE into several small components (outliner, bullet-charter, tree-charter, grapher, calendar), independent but completely capable of sharing data. Improve each component so it's the best at what it does, and eliminate all tools (such as drawing) that some other program will always do better. Then sell each component independently and cheaply. If someone buys all the components, you make more money than you do now; if not, you still win on volume. And move quickly, Symantec. The Cretaceous period is coming to an end.
Symantec -- 800/441-7234 -- 408/253-9600
Article 2 of 21 in series
by Matt Neuburg
Veteran readers of my contributions to TidBITS know that I am unabashedly obsessed with computer tools for the storage and retrieval of information. They also know that an almost unqualified rave review from me is a rare thingShow full article
Veteran readers of my contributions to TidBITS know that I am unabashedly obsessed with computer tools for the storage and retrieval of information. They also know that an almost unqualified rave review from me is a rare thing. Hold on to your hats, here it comes.
Take a simple, yet elegant, powerful, and above all useful fundamental idea as your program's basic metaphor. Then implement it with meticulous attention to the details of the interface, taking full advantage of the Mac's features to give lots of flexibility and convenience. That's the recipe for a great Macintosh application - such as the one I'm using right now.
The object of my new affections is IN CONTROL (about $85 discounted), from Attain Corporation. It's an outliner with a big difference. Outlines, you recall, are clumps of text structured as topics and (indented) subtopics, and since you can "expand" or "collapse" a topic's subtopics (to make them visible or invisible), or move a topic and its subtopics to another place in the outline, they are great for arranging, rearranging, and navigating information of all sorts.
Here's the IN CONTROL (IC) difference. To the right of the outline you can create any number of "columns;" and into each column you can enter information corresponding to each topic of the outline: a date, a number, a keyword, a comment, that sort of thing, each column representing some concept you want to associate with the outline's topics.
And why would you want to do that, you ask? Because now you can view your outline in new ways, by sorting or hiding topics according to the criteria of what's in the columns. Picture this:
Make your outline a list of things to do, arranged into topics by some convenient typology (e.g. Schoolwork, Housework, Phone Calls, etc.): now add a column for the date and time when you want to do each thing, sort on this, and Presto! You're looking at your schedule in chronological order.
Make your outline a list of your classical record albums, with subtopics listing every piece on each album: add columns for the date, the principal instrument, and the musical form of each piece, and now - want to know what albums contain flute concertos written between 1800 and 1850? Presto! Everything else is hidden, and you're left with a list of only those albums and those specific pieces.
To write an article (like this one!), build an outline of topics and subtopics, so you can brainstorm and rearrange ideas easily; beneath each subtopic, write sentences of actual text you want to have appear in the article. Add a column categorising each topic as a "heading" or a "paragraph," depending whether it's a topic description or the actual text. Want to rearrange the ideas? Presto! Show only the headings, and alter the outline to your heart's content, with no "paragraphs" visible to mar your view. When you're finished writing, Presto! Show just the "paragraphs" instead - and since what's exported is what's showing in the current view, you can now export just the actual text (and send it to TidBITS!).
Make your outline a bibliography of books and articles, with main topics by author's last name. Make columns for date, keywords, type ("Book" or "Article"), status ("Not yet read," "On order," or "Read"), and notes. Every entry in a column can hold 32K of styled text; that ought to be plenty for your notes! The notes will occupy vertical room in the window only if they are showing: Presto! Just hide the notes column, or use the menu to show just the first line of all topics, and you can view your bibliographic info conveniently. Use the keywords to show just those articles dealing with "Aeschylus," or do a search-match to show just those books for which the notes contain the word "Laryngeal." When you're finished, export just the bibliographic information, retaining text styles, straight into your word processor.
As these examples show, you can sort on different kinds of criterion. You classify a column as text, numeric, or date-time, and IC knows how to sort and co-sort accordingly. The techniques by which IC decides which topics to hide, called "matching," are even more sophisticated. You can hide or retain only those topics with a column entry identical to, containing, or greater or less than the current entry (or to stuff you type in a dialog box) - and again, comparison is done properly for text, numbers, and dates. Sorting and matching will not expose a topic that has been "collapsed" along with its co-topics into its governing topic, so this provides a further filter (that's important: collapsing and hiding are not the same, though both make a topic invisible). You can also manually select a topic or topics and hide or retain them directly. Furthermore, retained topics can be shown as an outline (in which case the topics that govern them are shown, even if they didn't match the requisite criteria, so as to make the outline levels meaningful) or in a simple one-column arrangement, called a "table." (After sorting, what you are shown is always a "table," since otherwise the governing topics might have to be repeated several times, making nonsense of the outline.)
It's important to understand that when you sort and hide topics this way, no change is made to your outline (although IC can also sort in ways that do rearrange topics); what's altered is your view of the information in the outline. You can toggle back and forth with a button-press between such an altered view, with some topics hidden and/or sorted, and the normal view of the outline. Even cooler, you can preserve an altered view. You can hide and sort, and IC remembers the criteria and actions by which you arrived at the current altered view. You can then name this view, specifying the particular features which you regard as important, and the name appears in a pup up menu. The whole operation can now be performed again at any time just by choosing from this menu. Doing this doesn't mean, "show me just the topics that were showing previously"; it means, "do the same matches, sorts, or other changes that I performed earlier, on this version of the outline." Such preserved views are called "scripts," and are easy to create and modify. (Scripts can be transferred to a new IC file, but not copied between existing files.)
So you might think of IC as an extended outliner. For extra bonus coolness, you can extend your outline right on out of IC itself: any topic in your outline can be "linked" to any document on your Mac (assuming you're running System 7, of course)! Once you've set up a link, you select that topic and hit a command-key, and the document is opened by its application. The possibilities for this feature seem endless: demos, presentations with pictures, catalogues of documents, indexing....
I'm sure that by now you're starting to think of all sorts of uses to which you could put IN CONTROL. The adaptability of IC is certainly inspiring. Its makers also seem to have found it a bit daunting. In our present niche-oriented software market, what is this thing they've created? It's an outliner, a date-book, a database, a writing tool, a table-maker, an indexer - you try to label it, I can't. Attain's own pedestrian label ("To-Do List Manager") does it scant justice; this, and the several pages in the manual devoted to "time management," suggests to me that they're aiming at a business market. I guess that "thinking people who want to organise and navigate information" (like me) isn't considered a worthwhile proportion of the population.
To make IC seem more like a To-Do List, there's a further feature: besides the columns that appear to the right of the outline, there is also a column that can appear to its left, consisting simply of a check-box for each topic. You can hide and sort on the checked-ness of these boxes, and the manual suggests you use them to mark whether you have performed the "to-do" item. This is a column by other means, modified to fit the specialised "to-do list" rubric; to me it seems an artificial appendage.
The check-boxes, though unnecessary, are at least useful and unobjectionable. Not so, I thought, the calendar-reminder facility, even though the manual goes to some lengths to push this as a major feature. The interface between the outline and the calendar is brilliant, to be sure; but I found the component as a whole weak to the point of uselessness, by comparison to the shareware Remember?, which I use. There is no capacity to enter regular events ("every Wednesday at 5"), so if you want to use IC as an appointment book and something in your life recurs regularly you have to enter a separate notation for each occurrence, one by one. Nor can you enter dates descriptively, ("the second Tuesday of November"); you must find November on the calendar and figure out which day is the second Tuesday. And that won't be fun either, since calendar navigation is primitive (no nice pop-up menus with month names or year numbers). If an appointment comes around, you can be reminded (through an extension) even if IC is not running; but the signal consists only of a beep and a flashing icon in the menu bar, and we all know what that's worth (on my first Mac, my Alarm DA flashed for three weeks the first time before I noticed). And if you want to know what you're being reminded of, you have to open the right IC file yourself, manually. Contrast this to Remember?, which brings up an obnoxious palette in front of everything describing what's happening, and lets you bring up the calendar and list of upcoming events instantly from there if necessary. In short, the calendar-reminder feature feels artificially and inadequately imposed upon IC - perhaps (but this is just a guess) in hopes of giving it more appeal to the lucrative business market. However, I don't need IC as a calendar, so I don't care.
Aside from this, IC's implementation is beautiful and thoughtful in its details. The document window has a removable bar with some popup menus and gorgeously drawn buttons across the top; the choices have been well made as to which functions to make accessible here. There is nice use of a changing cursor. You can Undo just about anything. In short, it's clear that serious thought has gone into making IC robust and intuitive, something I can't say of certain other "neat idea" applications I've had occasion to review in these e-pages.
Keyboard navigation between topics is superb, including commands to move up or down to the next topic at the same level, whether adjacent or not, to move to the topic governing the present one, and to move to the present topic's last subtopic. You can select topics contiguously or non-contiguously. You can promote all of a topic's subtopics, or demote all topics subsequent to this one at the same level (to make them subtopics of this one). You can copy a topic with or without its subtopics. A style-sheet can be set for the whole document, dictating the default font, size, style, and color for each outline topic level; activating the style-sheet does not wipe out features not specified (if you change a level's font to Helvetica but don't specify a style, italics are not lost), and multiple alternate style sheets for the document can be maintained using a "script". My one complaint is that there is no keyboard command to move the cursor a word at a time; commands to split and merge topics would have been helpful too, and it might have been nice if graphics could be pasted into the outline.
The outline is always at the left; everything to its right is a column. The width of the outline and of each column can be changed (or zeroed, if desired), and the relative position of columns shifted, by dragging in the bar at the top of the window. Each column's text can be given an independent default font, size, style, and color. A wonderful feature is that if a column is to contain keywords, you can enable fast entry of these: if you type the first letter(s) of a keyword in the column, the computer enters the rest, and if you hold down the mouse in the column, a pop-up menu containing the keywords appears. There is provision for multiple keywords in one column for a single topic; and you can set the sort order of keywords. Another neat thing is that you can set a column so that if you make a new topic, this column will contain the same value as its predecessor, or the next in a sequence of numbers. You can also cause a single value to be entered instantly in a column for all (visible) topics. There is spreadsheet-like keyboard navigation, as if topics and column entries were cells. Thus, IC is a rapid data entry tool.
You may want to use this power to create tables or text that you intend to use in other applications. IC can import or export by copy-and-paste or (to maintain formatting) by using XTND technology. Tab/return-delimited tables are imported as topic (first column) and columns, and vice versa for exporting. When importing, tabs (or option-spaces) at the start of a line are taken as indent information: thus, you can import from any word processor right into outline form. You can export the same way, or (with XTND) export topic indentations as nested paragraphs, using rulers. A clever feature is that hidden columns do not figure in importing, exporting, or printing, and hidden topics are not exported or printed either. This makes it easy to transfer or present data in just the desired format. One of the first things I did with IC was to import a huge table I was constructing in Word; with IC's easy data entry, I'll finish it twice as fast, then export it back to Word. (The only downside to importing is that the IC file can be larger by 30 to 100%, depending on the source.) IC also has good printing capabilities, intelligently managing tables which may spread over multiple pages horizontally and vertically, and providing a basic range of options such as margin size, headers and footers, grid lines, column title style, and alphanumeric topic labels for the outline.
The manual is splendidly written: clear, simple, small, explicit, graphic. I could have used a section gathering technical information; it is possible to err too far on the side of simplicity (not all your customers will be business nerds, Attain!). Also, "later in this chapter" is not much of a cross-reference; page numbers would help. There are twenty graphic online help screens, and balloon help; even the error alert boxes are informative rather than merely punitive. Two complaints about IC. First, I hate to harp on this, but is it really too much to ask that a program shouldn't mess up the "colors" on my 16-gray screen? Not only does IC do this, it sometimes turns its whole window black, and I have to go to some lengths to recover visibility. Second, a single bad interface decision: there is a situation where text jumps from under the mouse as you double-click on it, and you end up clicking in the wrong place. Attain should rethink this one.
IN CONTROL revolves around a powerful basic concept. The interface is clean, lean, reliable, helpful, and sensible. Put these two elements into the hands of just about any user, who surely will find the program so flexible and adaptable as to serve all kinds of needs both present and hitherto undreamt of, and you've got a whole which is greater than the sum of its parts. IC is already taking over many tasks on my computer that I had assigned to lesser workers. No doubt it can do the same for you.
Attain Corporation -- 617/776-2711 -- 617/776-1626 (fax)
Article 3 of 21 in series
by Matt Neuburg
Recently, an amazing program I'd never heard of rescued me from a quicksand of information I couldn't store and retrieve effectively, and from a quagmire of outliners, databases, contact managers, and calendars that couldn't help meShow full article
Recently, an amazing program I'd never heard of rescued me from a quicksand of information I couldn't store and retrieve effectively, and from a quagmire of outliners, databases, contact managers, and calendars that couldn't help me. What's more, this program - on which I now rely totally - and about which I shall herein proceed to rave intemperately is currently free.
Looking for Trouble -- The problem started when I switched from academia to business, and my needs changed drastically. I no longer wanted to store and retrieve only text (lectures and facts) or simple sets of items. I now edit a magazine, and I need to track prospective articles and their authors.
Suppose John Doe sends me email with an idea for an article on programming the Mac's Widget Manager. [A fictional component of the Mac Toolbox - we hope. -Geoff] Under an outline topic "Proposed Articles" I would put a sub-topic "Doe, John" (to go with other authors who had proposed articles), and under that a sub-sub-topic "Widget Manager" (to go with anything else he might propose). I also wanted further information for each topic, so I used IN Control and added columns for an email address, a miscellaneous memo, and the date we had corresponded, ending up with something like this:
Topic Address Memo Date ------------------- --------------- ---------- -------- Proposed Articles Doe, John email@example.com Widget Manager good idea! 1/4/96
But there's big inefficiency here: lots of empty space. After the outline (in the first column) I have three additional columns: address, memo, and date. Yet the address column is only used with the author's name, and I'm using the memo and date columns only with the article title, so there are gaps in the outline. This is ugly and error-prone: it's up to me, the user, to remember what each line represents, and to leave the address column blank after an article title.
Why such inefficiency? Because I'm trying to hierarchically arrange two different kinds of entities (three kinds, if you count the "Proposed Articles" header) where each kind has its own set of fields. But IN Control knows nothing of this.
Enter WebArranger -- WebArranger is really Arrange, a program produced by Common Knowledge Inc. during 1991-93 or so. I never heard of it then; but recently, CE Software picked it up, and until 16-Feb-96 is giving it away as a URL hoarder. They adapted it for this purpose using a plug-in module for talking to Netscape, importing its bookmark and history files, and tracking changes to Web sites. Ignoring the Web and URL features, though, WebArranger is at its core a miraculously ingenious program.
One caution: if you're like me, you won't understand WebArranger right away. It took me hours to grasp the basic metaphors and realize what was happening. If you can't find an old Arrange manual, you can download the Help file; it's quirky and outdated, but better than nothing. This article will help too, though the terms I'm using are not the official terminology (as I find the latter opaque and confusing).
With WebArranger, you define entities you want to store, and each entity has its own set of fields. Then you can build an outline in which any topic or subtopic can be any of those entities. For my example above, I might define a Header entity, an Author entity, and an Article entity. To facilitate display and navigation of the outline, WebArranger uses a summary line where each entity occupies a single line built by WebArranger according to a format you define. When you click a summary line, the entity expands to show each field, labelled and arranged vertically. You can also double-click to expand the entity into a window of its own (to avoid shoving lines off screen). So, my outline now works like this (everything but the three summary lines - which I've marked with an asterisk - would usually be hidden):
* Header [summary line, "Proposed articles"] Header name: Proposed Articles * Author [summary line, "John Doe"] First Name: John Last Name: Doe Email: firstname.lastname@example.org * Article [summary line, "Widget Manager... 1/4/96"] Title: Widget Manager Comments: good idea! Date: 1/4/96
WebArranger builds on this metaphor of fields in entities in outlines, in ways so useful that my co-workers complain about my screaming "Yes!" and jumping from my chair with delight. To avoid repetitiveness, please imagine me saying "But wait! There's still more!" before each of the next several paragraphs.
To help you store massive amounts of information, WebArranger provides a second, higher tier of outlining. Every outline of entities - such as the one we've just constructed - lives in a sub-folder which lives in a folder; i.e., a two-level organizational outline. This organization is shown at the left edge of the window, and clicking a sub-folder displays its contents in the main part of the window. So, I can have a folder called Business with two sub-folders inside it, Articles and Authors.
One benefit of this organization is that one author can be associated with more than one article. To save you from needless multiplication of entities (let's hear it for Occam's Razor), WebArranger lets you clone any entity, which is like making an alias to it elsewhere in the document. All the clones are identical and changes made to one are instantly reflected in all of them. So I can clone my author, John Doe, into the Authors sub-folder, and use that sub-folder as a repository of clones of all authors. Then, if any existing author proposes another article, I can clone him or her from the Authors repository when I make my entry in Articles.
Let's make another change. WebArranger allows entities to have link fields. A link field contains one or more entities (letting you store an entity within an entity), and those entities can be clones. This lets me restructure my entities so that the Author, instead of being a separate line of the outline, appears as a field of the Article, like this:
* Header [summary line, "Proposed articles"] Header name: Proposed Articles * Article [summary line, "Widget Manager... 1/4/96"] Title: Widget Manager Link field: * Author [summary line, "John Doe"] First Name: John Last Name: Doe Email: email@example.com Comments: good idea! Date: 1/4/96
Since a link field can contain any number of clones, this also solves the problem of articles having more than one author. In practice, it's also better to structure my fields in this way because link fields provide automatic look-up. If I create a new Article entity, a box pops up when I tab into its Author link field, where I type the last name of the author. The Author entity with that last name is then cloned automatically into the link field.
Conversely, to make my Authors sub-folder an effective repository of all Author entities, I can set it to auto-clone Author entities, any time an Author entity is created, a clone of it is automatically placed in the Authors sub-folder. Now, when I make a new Article entity and tab its Author link field and type the author's last name, if that Author entity already exists, it is automatically cloned into the Author link field (because the link field is set up to do this), and if not, I create it in the Author link field and it is automatically cloned into the Authors sub-folder (because the sub-folder is set up to do this).
All entities have certain "system fields" which are filled out automatically by WebArranger but are not shown unless you want them - for instance, the date and time this entity was created, and the date and time it was last modified. This feature is a godsend when you're using WebArranger as a contact manager. I've created an entity type called MemoDated, consisting of a text field and the entity's creation date. Each time an exchange about an article occurs, I make a new MemoDated entity and make it a subtopic to the article. This gives me dated records of the history of contacts concerning that article.
Queries and Views -- As you accumulate large amounts of data, you can query it in useful ways. One such way is to examine an outline using sorting and matching criteria. For instance, my auto-cloning Authors sub-folder grows in no particular order, but I generally want to look at it sorted by Last Name and First Name - and, on occasion I might add a matching criterion too, for instance looking at just those Authors who have no email address. A set of criteria for sorting and/or matching is called a View, and the rules for every View are automatically saved with the outline in a handy pop-up menu. A View shows either all the lines of the outline or just those which are of one specified entity type, and can combine this with a "table" structure where rows are entities and columns are fields (like a typical database browse window).
A View can also display as a calendar: you tell WebArranger what date field is relevant, and it puts the summary line for each entity into the right calendrical location. You can show a month at a time, a week at a time, or a day-book, and though there are some limitations the interface is remarkably flexible, in some ways beating even dedicated calendar programs like IN Control 3.5.
I can't possibly describe all of WebArranger's abilities here, so let me hasten through a brief concluding miscellany. There is a good Find feature which is remarkably fast. A Gather feature lets you collect clones of all entities that meet specified criteria. A Goto dialog lets you jump to a different sub-folder by typing the first few letters of its name. You can have multiple windows on a document. An Alarms feature turns any date field into an active reminder; WebArranger does not have to be open for the reminder to work (an extension handles it), and you can turn it off, "snooze" it for a specified time, or go to the corresponding item in your WebArranger document. A "grabber" control panel lets you copy the current selection in any program for later reference; again, WebArranger does not have to be open, and your "grabbed" items are imported into a designated home document the next time you open WebArranger.
Room to Grow -- There are things about WebArranger that could stand improvement. It's not for keeping large texts in (a field can hold a maximum of something like 10K). The outliner has deficient keyboard navigation. Certain actions have the side-effect of deselecting your current selection, which is counter-intuitive and causes you to lose your place. Also, export and printing are not great.
WebArranger is one of those programs that is picky about where you click. Clicking a summary line expands it, clicking its triangle shows or hides its sub-entities, and clicking its icon selects the entity itself. If you're like me, you're sure to miss much of the time.
Perhaps WebArranger's biggest flaw is when you want to examine the deep levels of entity types and field definitions. For instance, you can find out what a given sub-folder is auto-cloning (though not easily), but you can't find out in general what sub-folders are auto-cloning what sorts of entity. Similarly, you can learn all the names of all the fields used by all entities at once, but you can't find out what entity uses any particular field.
CE Software plans to make WebArranger part of a forthcoming DayVision product suite, but I wouldn't count on an interface improvement. Remember, this is CE, makers of QuicKeys (which offers a crummy interface to some pretty great software, although it's badly in need of an upgrade) and of QuickMail (which - in my opinion - is atrocious software with an interface that gets worse with each upgrade).
Nonetheless, the release of WebArranger as a freebie is a wonderful gift. This program saved my bacon when I needed to take notes on discussions I had at Macworld Expo, and is now my primary contact manager. The program makes large amounts and many sorts of data easy to arrange and navigate; in fact, you're tempted to keep your whole life in one gigantic document. If handing this program out for free is a hook to make me pay for a chain of upgrades, I'm a delighted addict.
CE Software -- 800/523-7638 -- 515/221-1801
515/221-2258 (fax) -- <firstname.lastname@example.org>
Article 4 of 21 in series
by Matt Neuburg
For many years, FileMaker Pro has been one of my standard tools for storing and retrieving structured information: with FileMaker, it's easy to build yourself an address book or a guide to your music collection, and its thorough scriptability makes it splendid for exchanging data with other applicationsShow full article
For many years, FileMaker Pro has been one of my standard tools for storing and retrieving structured information: with FileMaker, it's easy to build yourself an address book or a guide to your music collection, and its thorough scriptability makes it splendid for exchanging data with other applications. Version 3.0, dating from 1995, introduced relational database capabilities; but subsequent versions offered so little (and cost so much) that I never upgraded further. Then recently version 5, instead of improving core features, introduced some vastly higher pricing, and I wondered whether I hadn't backed the wrong horse.
Around this time I learned, with surprise, that Odesta's Helix was still alive. I had used Helix briefly in 1991, but then lost track of it. Helix (soon re-dubbed Double Helix) had been one of the earliest Mac products, dating back to 1984. It was ahead of its time, but was sent down an unproductive development path - basically, much time and effort went into creating a VAX-based server for Helix, whereupon personal computers suddenly got faster and cheaper than a VAX would ever be (can you say Mac IIfx?) - and the company split up in 1992. The product was renamed again, as Helix Express, and more or less languished. Now it has been taken over by The Chip Merchant, which is run by a Helix enthusiast, and is being subjected to the nightmarish process of modernizing ancient legacy code, fixing memory leaks, and squashing bugs. Meanwhile, amazingly, the basic Helix product, now renamed Helix RADE (Rapid Application Development Environment), is free.
In the Nucleus -- Helix RADE (I'll just call it Helix) is an environment for designing databases and then working with the data (inputting, viewing, querying and sorting, exporting, printing). The design process is unusually visual and object-based, revolving around icons and windows, in ways somewhat reminiscent of Prograph (see "Get Your Hands on Prograph" in TidBITS-312). The terminology is also rather quirky, so bear with me.
A database file created by Helix, containing the database structure and the data, is called a "collection." Only one collection can be open at a time. It is represented initially as an empty window, into which you drag icons to represent relations; each relation is a table of data, where all the records (the rows) will consist of the same fields (the columns) - what FileMaker would call a database. Thus, a one-relation collection is a flat-file database; a two-or-more-relation collection can be a relational database, as I'll explain later.
Double-click a relation icon, and another empty window opens, into which you drag more icons. These are of many different types:
A field is a category of data that each record is to have, such as "last name" or "age".
An index is an instruction that a sorted order be maintained for one or more fields.
An abacus is a calculation, such as "first name followed by space followed by last name".
A template is like a FileMaker layout, where you arrange fields on the page.
A view is like FileMaker's browse mode; it portrays some particular template, but is where you actually enter and view live data.
A query is a form, attached to a view, which you can open to change what subset of the data is shown in that view.
A post is an action to be performed automatically when you do something in a view, such as entering data; chiefly, it's a way of maintaining automatic integrity of data across relations. I'll talk more about this later.
Each icon, once dragged into a relation window, just sits there until you do something with it. First, you name it, just like naming a file in the Finder. Then you double-click it to open its window and edit it. In a field's window, you specify its data type and validation rules. In an index's window, you specify what field(s) to sort. In an abacus's window, you describe the desired calculation: this too is completely icon-based, as you drag icons representing operations and fields into the window and arrange them in a dataflow diagram. For example, to say "first name followed by space followed by last name", you drag in a "followed by" icon, then drag the "first name" field into its first part and set a space character as its second part; then you drag in a second "followed by" icon, feed the output arrow from the first one into the second's first part, and drag the "last name" field into its second part.
A template window starts out as a blank sheet of paper with some rectangle drawing tools. What you draw is crucial, because a view, you recall, is the only place where you enter or examine any actual data, and every view is a representation of some one template; so if you ever want to be able to set directly the value of a record's "last name" field, that field must appear in a template!
Templates come in two forms. A template showing fields for one record at a time is an entry template; in a view that uses an entry template, you navigate records via Next/Previous Record menu items. A template showing fields for all records at once is a list template, and is established by drawing a repeat rectangle around the data to be listed. For example, if you draw a repeat rectangle around the "last name" field in a template, then a view that uses this template will list the last name values for all the records at once. (By "all", I mean "all that this view shows"; you can limit or order the set of data shown, with a query or index attached to a view.)
A list template can appear within another template. For any view that uses the outer template, you specify a field in each template's relation; the inner template will then list only those records of its relation where the data of those two fields match. This is how you make your database relational. The display of the inner template material is extremely flexible, so that Helix's implementation of relationality is extremely powerful: for example, you can specify the sort order of the inner list; you can specify a query further limiting the inner list's records; and you can nest list templates, for additional layers of relationality.
Helix runs in two modes, developer mode and user mode. Developer mode is what I've been talking about all this time. In user mode, you see only certain views and menu items, and have only certain types of access to those views, as predetermined in developer mode. Surprisingly, this can be useful even if you are your only user; when you are done designing, it's nice to switch to user mode, eliminating extraneous windows, and just enter and retrieve your data.
Acid Test -- To test Helix for this review, I reproduced, as a Helix collection, the structure, data, and functionality of a system of related FileMaker databases that we used when I was editing a Mac programming magazine. This system had proven almost too much for FileMaker to handle, and I wanted to see if Helix could do better. I will now provide some gory details, so skip the next couple of paragraphs if you have a weak stomach.
The system tracked articles submitted and published, plus payments to authors. An article could comprise more than one "fragment" (for example, in our Readers Tips column, each tip was a fragment); so there were no authors of articles, only authors of fragments. And a fragment could have more than one author. So far, that's three databases: articles, fragments, authors. For every article, we needed a list of author-fragment-payment triplets. But how, in FileMaker, could a portal in the articles database show authors? Authors had no direct relationship to articles, and portals could not contain portals, or be limited through a query.
Our solution was an extra database, an intermediate "link" pairing fragments with authors (and payments). The articles database could have a portal on this fragment-author database; but how would it know which fragment-author pairs to list? Clearly, the article database's key must match an article key in the fragment-author database. But where would that key's value come from? There were no articles in the fragment-author database; articles were paired with fragments in the fragments database! So we forced each record in the fragment-author database to learn what article it was a part of, through a lookup on the fragments database.
This was just one of many complex portal/lookup tricks we used to hook up the information. The problem here was not the extra fragment-author database (that's standard procedure with many-to-many relationships), but the dreadful fragility of the data's integrity. Lookups in FileMaker were not live, so we had to keep running a script in the articles database that made the link database refresh its lookups. When creating a new article, tasks had to be performed in the right order, to ensure that the fragment-author database was updated correctly behind the scenes; despite precautions, it could easily acquire invalid records, and had to be double-checked often by hand.
The Helix version turned out to be far simpler and far more robust, and took me just two days to create after reading the documentation; it would have been much quicker for an expert. To list fragment-author pairs within a view of an article still requires the fragment-author relation, but in a much more straightforward way: an articles template holds a fragments list template, keying on the article, which in turn holds a fragment-author template, keying on the fragment. Integrity is maintained behind the scenes through a post: when you enter an author for a fragment in the fragments relation, Helix automatically creates a new record pairing them in the fragment-author relation - but only if they are not already paired.
The Helix version is also far more comprehensible to a developer. FileMaker hides crucial information in various modal dialogs: the Define Fields dialog and its Options sub-dialog, the Field Format dialog, the Portal Setup dialog, ScriptMaker and its Script Definition sub-dialog. In Helix, on the other hand, everything is a top-level entity, an icon in a window, and no icon window is modal, so you can open and study many at once - indeed, in an icon window you can double-click another icon's name to open that icon's window! You can view a relation window as a list (like Finder Name view), showing useful information about each icon. Each icon also has a Get Info window, where you can enter a comment and see the names of all icons that use this one. Finally, Helix prevents or warns you if you perform any invalidating action, such as trying to delete an icon used by another.
Helix derives great fluidity and power from the object-based independence of its entities. Consider calculations. In FileMaker, a calculation is basically a kind of field. In Helix, an abacus is just an abacus, and so you can use it however you like: it can provide data or validation for a field, a sort order for an index, a limiting query for a view or for a field entry pop-up menu. On the other hand, things that don't need to be entities, are not. In FileMaker, relationality between databases is one more setting to be reached through a series of dialogs; but Helix knows that this is just a way of looking at data, so it's merely an aspect of a particular view. The general feeling in FileMaker is that you start with a database and drill into it from various places to access its parts; in Helix, you start with the parts, and tie them together to form a database.
Under the Electron Microscope -- Helix is not for the faint of heart. The manual (fortunately due to be rewritten) is a massive series of PDFs, more a specification than an explanation: it has some typos, and the pictures are mostly indecipherable, a serious flaw for a visual language. It fails utterly to teach you the Helix way of thinking, the peculiar culture and tricks handed down by past masters. The learning curve is hyperbolically steep; either you'll suddenly have an "Aha" moment and pop past it, like bursting through a wall, or you'll fall off the mountain.
Helix still has some bugs - I crashed several times - and many faults. Revision continues, so some of these may soon vanish; but at present, the new user is likely to find Helix quirky and fossilized. Over the years, Helix has grown like Frankenstein's Monster; new bits were sewn on without touching old bits, many of which date back all the way to 1984 - and they feel like it, especially the interface, which incorporates no modern elements such as balloon help or tabbed panels.
Navigation is a big problem. There is no Window menu (a dreadful omission), no hierarchical outline view of your collection, and no way to navigate upwards (from an Index window to its containing Relation window, for example). So you spend most of your time lost; even if you can see an icon's name and open its window, you may not know what relation it is part of, so you have to drill down into every relation looking for it.
Certain crucial windows are incomprehensible unless you're very experienced or looking at the manual, and often present their information in a clumsy piecemeal fashion. The View Setup window, where you create the relationality between an outer and an inner template, is atrocious: the space is too narrow for the names you're trying to read, and if you add another inner template the dialog forgets all its previous settings.
You cannot edit data in a list view - though you can double-click a listed record (or multiple selected records) to open it in an entry view where you can edit. Inner lists don't scroll, or support multiple selection. On the other hand, list views support user-selectable sort orders, while entry views don't - a curious asymmetry.
Here's a final miscellany. You can only have eight colors. A multiple-choice field can't be represented as radio buttons. There aren't enough menu shortcuts, because the Command key is the only modifier. There is no way to learn which record of the current found set you're looking at. An abacus has no find-and-replace functionality, so sometimes you have to export your data, munge it, and re-import it.
Replication & Evolution -- Helix is internally scriptable, via menu items or buttons in views; but the only scriptable actions, besides opening views, are those normally available as menu items. That's very weak compared with FileMaker, but posts often make a script unnecessary, and buttons can implement a form of branching and looping, which scripts themselves lack.
Helix can't run AppleScript scripts, so any inter-application communication must originate externally. It responds, not to AppleScript, but to some rather oddly structured Apple events; you'll need a program like Frontier to send them. The repertoire is very limited - fetch a record, load a record, delete a record - but you could probably manage by arranging your database cleverly beforehand, perhaps with an occasional boost from QuicKeys or OneClick. So if the question is, "Can Helix act as a CGI application behind my Web server?" the answer is: Maybe, but not alone, and not easily.
I have not seen the commercial Helix products; there are two. Helix Converter ($500) turns your database into a stand-alone application (in permanent user mode). Helix Client/Server lets multiple users access a database via AppleTalk. It might be preferable for serious CGI work, and without it you can't run two copies of Helix on the same local network. It starts at $300 for two clients and goes up from there.
My exploration of Helix has certainly made me an addict, if not a convert. Once bug-squashing ends, the next big step will be a feature release. It isn't clear what this might include - a truly modern Helix might benefit from an overhauled interface, fuller scriptability, and TCP/IP and ODBC awareness - or what the future pricing model will be. But the present pricing model is unbeatable: a powerfully relational database program at no cost. You have nothing to lose but your dependence on FileMaker.
Helix requires a PowerPC-based Macintosh running System 7.5.5 or later.
[Note: This article owes much to the generous personal attention and informative guidance of Matt Strange of Helix Technical Support.]
Article 5 of 21 in series
by Matt Neuburg
Computers are marvelous at storage and retrieval of information, so why are some things so hard to keep track of? You probably know where you put the draft of your novel, or that letter to your congressmanShow full article
Computers are marvelous at storage and retrieval of information, so why are some things so hard to keep track of? You probably know where you put the draft of your novel, or that letter to your congressman. I'm talking here about bits of information, like the list of things to do before your kid's birthday party, the patentable idea you thought of last week, or the questions you plan to ask your boss at tomorrow's meeting. You may have hundreds, even thousands of miscellaneous "snippets" or "nuggets" like this; what you need is a virtual shoe box into which to toss them as they arise, and somehow retrieve them later in an orderly fashion.
As a fan of computer-based organizational devices, I'm often asked to recommend a "snippet keeper" of this sort. When the question arose recently on TidBITS Talk, a clamor of recommendations resulted, showing how great the need is. Apart from the obvious outliners and databases such as I've discussed here in the past, people use a vast range of solutions: text-based low-tech utilities, dedicated snippet organizers, and even programs intended for something else, such as email. My own current favorite is Idea Keeper, by Glenn Berntson of Plum Island Software.
What It Is -- Idea Keeper rests upon a brilliantly simple framework. The basis of organization is a folder on your hard disk; you can have many such folders, and you can easily switch among them, but only one can be open in Idea Keeper at any moment. The current folder's contents are displayed in Idea Keeper's Organizer Window as a two-level list: a column of "topics" and a column showing the "ideas" within the currently selected topic. Double-click an idea listing, and you see a word-processing window corresponding to it. Thus, your granular data (your snippets) consist of individual text windows; the three-level hierarchy of folder, topic, and idea which categorizes them; this organization is sufficient to give every snippet a meaningful place, but shallow enough to ensure convenience.
What You Can Store -- Ideas are text windows. But mere text isn't the only thing these windows can contain. You can style the text, and you can also save common style settings such as "Palatino 12 blue underlined" as templates that you can instantly apply to any text. For each paragraph, you can adjust line spacing, margins, indent, and alignment, and these settings can be saved as templates too. The text can contain inline pictures, and even sounds (indicated by an icon that you click to play the sound).
An idea can contain checkboxes, which you click to toggle their state; and you can have "alarm objects" that cause an alert to appear at a given date and time if Idea Keeper is running. Thus, a text window can become a to-do list, possibly with live reminders.
An idea can contain Web, FTP, and mail URLs; clicking one does the expected thing in the expected helper program (as determined by your Internet Config settings), so Idea Keeper can work as a bookmark program as well.
An idea can contain file references (aliases): click the reference to open the file from the Finder. Thus, Idea Keeper can help organize files on disk, and (more important) it needn't store something internally in order to contain it - a PDF, or a QuickTime movie file, can be a snippet, because an idea can hold a live reference to that file.
Finally, you can display any idea window as an outline. Idea Keeper's notion of outlining is rather primitive, reminding me of the rhinoceros depicted by Dürer, who has obviously never seen a real one (for example, reorganizing is clumsy and navigation is nonexistent); but it's improving and adds a valuable further level of hierarchical organization for the text, to-do items, URLs, or file references that the idea may contain.
How You Can Store It -- Even the most capacious shoe box is useless if you can't find it, or if you can't get the lid off. Fortunately, you can enter information into Idea Keeper easily, and in many different ways.
Obviously, if an idea is open, you can type into it, or copy from another application, switch to Idea Keeper, and paste. Also, working within Idea Keeper, you can import a text file as an idea, or all the text files in a folder (each becomes an idea); you can also copy an entire topic from one folder into another. Idea Keeper can import Palm Database files as ideas, or as topics broken up into ideas according to their bookmarks. Pictures can be imported with automatic format conversion via QuickTime.
But you don't have to switch to Idea Keeper to move information into it; as long as Idea Keeper is running, a key-combination lets you grab the clipboard contents, or you can drag or paste into a tiny floating palette, without leaving the application in which you're working. Idea Keeper captures the material as a new idea. A dialog can appear asking what topic of the current folder to put the idea in, or you can just have the idea go into Idea Keeper's Clippings Window, a sort of global topic belonging to no folder - the point being that you can move the clippings window's ideas into actual topics later.
When text arrives into Idea Keeper, you may want some extra munging performed. You can strip extra spaces, extra return characters, linefeed characters, and email quote characters; Idea Keeper can perform any of these transformations automatically as the text arrives, or you can invoke them later to operate on selected text within an idea. Also, Idea Keeper can convert URLs to URL objects as the text arrives; this simplifies importing a browser bookmark file, or the results of a Sherlock search, as a series of live URLs.
How You Can Retrieve It -- Once material is in your shoe box, you obviously want to be able to get it back out again. If you're fairly conscientious in your organization, the folder/topic/idea hierarchy may well lead you directly to the desired snippet. But Idea Keeper also provides several ways of cutting through this hierarchy.
First, you can maintain a set of keywords, and apply one or more of them to any idea. Unfortunately, the entire keyword mechanism is disappointingly primitive: keywords are global, not specific to each folder; they are applied or inspected through a pop-up menu, which is a dreadful interface; and you can't do a boolean search - you can open those ideas to which some one keyword is applied, and that's all. Still, it's better than nothing.
Second, you can do a text search. You can either do a successive find or a global search; the latter displays a single window listing all ideas and objects (such as URLs) whose text matches your search. Unfortunately, there is no whole-word matching, so the results usually include a lot of undesired matches.
Finally, there's hypertext. This is one of Idea Keeper's best features. Within Idea 1, to make a link to Idea 2, drag Idea 2's listing from the organizer window into Idea 1. Or, to make a link to a specific locus within Idea 2, create an "anchor" at that point, and drag the anchor into Idea 1. Now you have a link in Idea 1 which, when clicked, jumps you to Idea 2. Furthermore, there is a "Back" command, so you can navigate via links and return, as in a Web browser. Thus, Idea Keeper encourages hypertextual organization and navigation. Unfortunately, these links work only within a folder. There is a device for linking between ideas in different folders: you can export an idea to the Finder as an alias file which you later drag into another idea. The result behaves like an idea link, but is actually a file link, and will break if the alias file is lost.
To share your snippets with others, you can export an idea as a text file, or a topic as a folder of text files, or multiple ideas as a single text file. For example, I wrote this review in Idea Keeper, then exported the whole folder as a single text file and opened it with Nisus Writer for final editing. (Unfortunately, some information was needlessly lost in this process; in particular, I had to go back and copy across the URLs individually.) Also, ideas or entire topics can be exported as Doc-formatted Palm files.
You can also export a document as a stand-alone application. What results is a folder of ideas embedded into a sort of read-only version of Idea Keeper; navigation by topic and by idea still works, as do hyperlinks and URLs. Thus, Idea Keeper becomes a tool for creating online documentation, rather like DOCMaker.
Finally, Idea Keeper is sufficiently scriptable that Apple events can query it and extract the text of ideas. This might be useful, for example, as a way to move Idea Keeper data directly into HyperCard or FileMaker while preserving the topic/idea structure.
Worth Trying -- Idea Keeper is a tremendously original program - so original that its unusual interface and non-standard behavior may create a bad initial impression. My advice: persist! Interface and behavior can be heavily customized to suit your expectations and needs, and after you've used Idea Keeper for a while, and have absorbed its paradigm and its quirks, you may come to see it, as I do, as proof that the Macintosh interface, so far from being exhausted, is capable of something new, refreshing, and powerful.
There are many aspects of this originality that I haven't even touched on in this review. There are brilliant toolbars, ingenious dialogs, extensive use of drag & drop, and immense online help (in the form of two Idea Keeper folders). This is a program that reflects deep concern for the needs of the user, and deep thought as to how best to meet them.
That's not to say that Idea Keeper is perfect. It is clearly the work of an amateur - a gifted, dedicated amateur, but an amateur nonetheless. In the course of preparing this review, I experienced crashes, freezes, and numerous interface misbehaviors. However, Glenn Berntson is extremely responsive and was quick to fix problems as I reported them. Indeed, it is partly for this reason that I suggest you try Idea Keeper: the more users it finds, the more testing it receives, the more suggestions are sent to its author, the better it will become. But of course the main reason I recommend Idea Keeper is that you just might like it enough to make it your snippet keeper. I certainly do.
Idea Keeper is a 2.6 MB download and requires 7 MB for installation; it prefers 12 MB of RAM. The program costs $30 shareware; the download is not disabled in any way.
Article 6 of 21 in series
by Matt Neuburg
Remember the Roach Motel? "Roaches check in, but they don't check out." Now Boswell, from Copernican Technologies, Inc., wants to do the same for your text documentsShow full article
Remember the Roach Motel? "Roaches check in, but they don't check out." Now Boswell, from Copernican Technologies, Inc., wants to do the same for your text documents. It's a text archiver; you put text snippets into it, and afterwards you access these snippets through lists that combine them in various ways, but you can never delete them, accidentally or otherwise.
Why is this program called "Boswell?" Copernican says it's because it's easier to spell than "Amanuensis" (one who takes dictation or copies manuscripts). But James Boswell, who wrote the celebrated Life of Samuel Johnson, perhaps one of the greatest biographies of all time, was no one's amanuensis; he was a traveller, man-about-town, essayist, lawyer, laird, and ardent lover of intellectual and artistic achievement in that most intellectual and artistic of times and places, 18th century England. Through his frank and vivid journal, he is also one of the few historical figures one feels one understands intimately. Both the biography and the journal testify to the virtues of keeping good notes; Boswell the program wants to help you do the same.
Knowledge of the Second Kind -- "Knowledge is of two kinds: we know a subject ourselves, or we know where we can find information upon it." - Samuel Johnson
Boswell creates a storage file on your hard disk, in 1 MB increments; into this file you will be placing snippets of text. A snippet can begin life within Boswell itself; you can type or paste text into the new snippet, and this text can be styled. Alternatively, you can import a text file, individually or by the folder.
Newly created or newly imported snippets reside in a kind of staging area. Here you can modify three fields: the body; the title; and a "comments" field. What you do at this point can be important, because later you'll be using keywords to search for snippets. The comments field is a particularly good place to enter these.
From the staging area, a snippet is placed into storage. At that point you are no longer able to edit it (although you can copy it, making a new editable snippet in the staging area). You also can't delete snippets from storage. There is no built-in way to browse the storage as a whole. Rather, you proceed to create lists of snippets.
These lists are just ways of viewing your data. A list may consist of any subset of your snippets, which can appear in any number of lists. Deleting a snippet from a list, or deleting an entire list, has no effect upon any snippets. But although they are just views, lists are not mere ephemera; they are the backbone of your work with Boswell. They persist until you explicitly delete them, and you are expected to give them useful names. At any time, you can see a list of all your lists, and open any of them. Clearly, the important question is: how does a snippet get into a list?
There are several ways. If you can see a snippet, a dialog lets you manage which lists should include it, or you can add it to one or more lists using drag & drop. A dialog lets you populate a list using search criteria. Also, you can associate certain keywords with certain lists and then tell Boswell to add a snippet automatically to any list that has any keywords contained in that snippet.
That's all there is to it. You make lists, and using them, you view your snippets. You can also copy and paste (or drag & drop) text from a snippet into another program; and you can export an entire list, meaning all the fields of all its snippets, as a single text file.
Paved with Good Intentions -- I disagree with the developers' assumptions and design decisions with regard to several aspects of Boswell:
Boswell stores only text. However, most of the documents in my life are not text; they're PDFs, Internet Explorer Web archives, or Word documents. Why can't Boswell store aliases, or entire documents? It might not be able to search them, but at least it could archive them and organize them through keywords and lists.
You can't delete a stored snippet. (In fact, you can't even delete an imported snippet from the staging area; it goes into storage eventually, willy nilly.) The developers seem to have a fixed idea that this is somehow one of Boswell's major attractions; their stubborn resistance to all efforts by the public to disabuse them of it has been most impressive. The trouble isn't just that your storage file keeps growing, but that it takes more work to avoid irrelevant material in a search. Other concerns that surfaced in TidBITS Talk include the worry of what happens if you accidentally feed Boswell a very large file, or what happens if some of the information in your Boswell file turns out to be highly sensitive.
Keywords aren't really keywords. They aren't a feature attached to a snippet; they are just some of a snippet's text. For example, you can't distinguish "Adam" as a keyword from "Adam" as content, and a snippet containing "Adamant" would be seen as containing the keyword "Adam." Most important, this means that, since you can't edit a stored snippet, you can't set keywords for a stored snippet. Yet, while the snippet is still in the staging area, and editable, how can you be prescient enough to know what keywords you'll eventually want? Keyword decisions emerge from experience of usage and evolving needs, and you can get that experience only after storing the snippet, when it can't be modified.
You can't add fields. This makes effective searching difficult. Without fields, for example, you can't distinguish readily between messages that mention Adam and messages from Adam.
Here's a miscellany of further flaws. When importing a file, styling is lost. A snippet must be less then 32K characters; there's nothing wrong with that, but when you import a folder of files, long files are truncated, not split, and you are not told which ones. There is no way to learn all the keywords associated with a given list - a serious oversight. Automatic keyword-based addition of a snippet to lists is too automatic: you can't "lock" a list, and there's no intermediate confirmation dialog, so Boswell can easily clutter your existing lists. Search criteria aren't saved, so there's no telling how a list was derived, and no way to reconstruct it if it gets messed up.
Finally, Boswell's interface is fairly non-standard. That's no crime; personally, I love an original interface, and Boswell's is quite pleasant, with some interesting use of drag & drop. But Boswell ignores even some of the most basic Mac conventions, such as the notion that you select things, then act upon them all; so, for example, you can't select just certain snippets and give them a particular tag or add a certain keyword to their comments. That's unnecessarily frustrating and inconvenient. The manual intimates that Boswell's developers are well aware that this is an unusual design decision, and implies that they gave it some thought. Well then, as with so much else about this program, they thought a lot, but they thought wrong.
The Butt End -- To James Boswell we owe our knowledge of Oliver Goldsmith's assessment of Samuel Johnson: you couldn't argue with him, because "when his pistol misses fire, he knocks you down with the butt end of it." In the case of Boswell the program, the "butt end" that knocks you down is the manual. Much have I travelled in the realms of jargon, but I never before saw so much misappropriation of terminology crowded into one place: "journal", "archive", "notebook", "entry", "library", "fluid", "frozen", "browser", "hub", "zip", "zap", "zip-zap", and more. It's all quite mind-numbing, rather unbelievable, and thoroughly unnecessary, since Boswell is a very simple program.
TidBITS readers know that I'm hugely sympathetic to, and practically obsessed with, information storage and retrieval utilities. And as a way of organizing data, Boswell's persistent lists are a brilliant and exciting device. Yet I can't quite envision what I'd use Boswell for. I wouldn't import my Eudora mail messages into it because Eudora itself is better at searching archived messages. I wouldn't use it as a contact or bibliography manager because it lacks fields. I wouldn't use it as a writing tool because snippets are unordered. I can imagine using Boswell to get a grip on miscellaneous notes, but I feel put off by the inability to delete - I wish I could use it to organize without also being forced to archive. On the whole, I still prefer a true database such as Helix, an outliner such as MORE, a field-based outliner such as IN Control or Web Arranger, a dedicated snippet organizer such as Idea Keeper, or even just good old HyperCard (doesn't anyone remember Mark Zimmerman's FreeText?). Still, if what it does is what you want done, Boswell has the inviting virtues of ease and simplicity; you'll have to decide for yourself whether the price tag cancels the invitation.
Boswell costs $130, and requires a PowerPC-based Macintosh running System 7.1.1 or higher. A demo is available as a 1.6 MB download.
Article 7 of 21 in series
by Matt Neuburg
Over the course of my relentless lifelong search for useful ways to squirrel away information on my computer, organize it, and find it again later, I've reported in TidBITS on various outliners, databases, writing tools, and combinations thereof that have appealed to me or that I hoped might appeal to meShow full article
Over the course of my relentless lifelong search for useful ways to squirrel away information on my computer, organize it, and find it again later, I've reported in TidBITS on various outliners, databases, writing tools, and combinations thereof that have appealed to me or that I hoped might appeal to me. Whenever one of my reviews appears, I get email messages from readers telling me about some alternative program they like to use. Typically, I investigate these; if I find myself intrigued by the suggested program, I may report on it, but otherwise I generally remain silent, my rules being that TidBITS is first and foremost about the experiences of its contributors (rather than attempting to be comprehensive purely for the sake of completeness) and that TidBITS prefers to focus on the positive.
In this article, I'm going to break my rules by describing briefly three inexpensive "snippet keepers" - programs for storing miscellaneous bits of text - that don't particularly appeal to me, but that do strongly appeal to some TidBITS readers. Why would I do such a thing? Mostly because my tastes aren't everyone's. For example, I tend to like such things as multiple hierarchical levels of organization and scriptability; but many folks feel that simplicity is a chief virtue, and that fewer features are better. They want a program that does one thing well, is easy to use, and can be learned quickly, preferably without even reading the manual. These three programs meet that description; plus, they are all free to try and inexpensive to purchase. For each one, I'll try to give a sense of why I don't use it, not in order to imply that you shouldn't, but just to clarify my own biases. My purpose is a positive one - to let you know that these programs exist and might possibly interest you more than they do me.
StickyBrain 1.2.1 -- In Chronos's StickyBrain, each window is a note (a text snippet). These windows are modeled on those of the Stickies utility that comes with your Mac, which are themselves modeled on 3M's Post-it Notes. They have no scrollbars; they have a thin title bar that vanishes when the note isn't frontmost, a tiny L-shaped grow icon in the lower right corner, and a colored background. StickyBrain also lets you use a picture or texture as background, or you can escape the Post-it Notes look altogether and give a note an ordinary Platinum appearance. Unlike Stickies, a StickyBrain window is a full-fledged styled text editor.
StickyBrain lets you show and hide individual notes, and its chief organizational device for helping with this is the "category." You can create as many categories as you like, and you can assign default appearance features to each category (background color, text styling, initial text, initial size, and so on); a note will have its category's default features when it is created or when its category is changed. You're also free to override these for any particular note. You can show just the notes of any one category; and you can use a list of all your notes to show any particular note.
Through a supplementary background application called HotKey, you can use key combinations to access certain StickyBrain features from within other applications, even when StickyBrain isn't running. A category's key combination copies the current selection into it as a new note; a note's key combination pastes its contents into the current application.
There are also numerous special features, many of them remarkably similar to Idea Keeper, which I reviewed a bit over a year ago. You can password protect a note, and a note can include an alarm. A note can include an email address that will create a new message in your email program, a URL that will navigate in your browser, or a file alias that will launch the file. A note can include boxes that you can click to show or hide a check mark, making a to-do list. You can search and replace text, across multiple notes if you like. There's even inline spell-checking.
StickyBrain is certainly full-featured, but to me, Stickies themselves have always seemed a dreadful metaphor, with the no-scrollbar window being the worst possible editing milieu; Post-it Notes are just clutter, and even though you can change the window style to the more standard Platinum appearance, the fundamental StickyBrain action of summoning simultaneously all the notes of one category feels like clutter on steroids. StickyBrain's background features depend purely on key combinations which can rapidly grow too numerous to be useful. There's no export feature, and your information lives all in a single file in a proprietary format; what if this became corrupted? Still, many readers swear by StickyBrain, so it might be your cup of tea as well.
The $35 Sticky Brain runs on any Mac with Mac OS 8.1 or higher, and requires 5 MB of RAM, 5 MB of disk space, and a 640 by 480 screen or larger.
EZNote 2.01 -- John Holder's EZNote used to be a control panel with a rather modal interface, but now it's an ordinary application permitting multiple windows, which is much nicer. It maintains snippets of styled text as files within folders; these folders are treated as categories, with the text files within them treated as notes, and everything lives inside a main folder you designate. In fact, you can browse your whole hard disk with EZNote and create or examine the contents of folders anywhere (any file of type TEXT will be seen as a note). However, EZNote sees only the top-level folders of its designated main folder as categories, and it works with them in a special way. For example, you can navigate instantly to a category, transfer a note to a category, and so forth.
An EZNote window consists of a browser pane and an editing pane. The browser pane, on the left, lists in a column all the folders and text files in the current folder. Selecting a text file's name in the browser pane displays its contents in the editing pane. You get the standard basic behaviors for styled editing, plus you can have named text styles. You can search and replace, across multiple notes if you like. A number of plug-ins let you munge selected text in various ways (change case, strip linefeeds, strip HTML tags, that sort of thing). Switching to a different text file listing in the browser automatically saves the current file.
EZNote works well as a background application, through keyboard shortcuts that you can configure, or through a floating palette that appears anywhere. The floating palette offers less functionality than the keyboard shortcuts provide, but it does solve a major problem that StickyBrain doesn't: with no shortcut at all, you can designate the category in which to create a new note from the current selection, or choose any note from any category to paste at the current insertion point. EZNote thus implements multiple styled-text clipboards, and is great for boilerplate that you need to paste often. You can also run a plug-in on the selected text. Conversely, within EZNote, you can create a new note from the clipboard, and you can paste the selection into any running application.
EZNote has a few shortcomings. You can't export multiple notes (though you can append each note to a single note first, and export that). You can't delete a category (but you can delete the folder itself, in the Finder). And I personally consider the save-without-asking behavior dangerous. On the other hand, in my view, EZNote's interface, though some details are slightly clumsy, is vastly better than StickyBrain's, and there is certainly much comfort in keeping your snippets in a plain text file. If you don't need StickyBrain's visual fluff (like background textures) or its extra features (like spell-checking, to-do boxes, or file aliases), I think EZNote is, hands down, a better choice.
EZNote runs on any Mac with System 7 or higher, needs only 2 MB of RAM and less than 2 MB of hard disk, and costs a mere $20 shareware. While you're visiting the author's Web site you might want to look into his other utilities; if what you really wanted was multiple clipboards, or if you want to store more than text, his QuickScrap control panel and ScrapIt Pro application are well worth considering.
Z-Write 1.2.1 -- The window of Stone Table Software's Z-Write is remarkably similar to EZNote's: a list of notes runs down the left side, and clicking a note's name brings up the note's content for editing in the right side. Like EZNote, you're editing styled text, and you can create named styles; and like EZNote, there's a miscellany of text-munging features, such as changing case, eliminating multiple spaces, and so forth. However, Z-Write has no categories; instead, it has documents, and what you're seeing are all the notes in a document. What's special about Z-Write is that it's intended as a writing tool; so you can rearrange the notes (which Z-Write calls "sections"), drag entire notes from one document to another, and export selected notes as styled text, RTF, or HTML.
Z-Write provides many extras useful to writers. There is good keyboard navigation, and text styling can be copied and pasted. You can insert bookmark tags, which are just ordinary text markup, such as "<bookmark myMark>", and then jump to any bookmark using a pop-up menu. You can insert hyperlinks, such as "<link myMark>"; Command-clicking on a hyperlink jumps to the thing it names, which can be a bookmark tag or a note. You can define glossary items (boilerplated named text), and then insert one with a pop-up menu or by typing its name. There's also an "<insert xxx>" tag; when this appears in a note you print or export, the note called "xxx" is substituted for the tag in the output.
Z-Write is a fine milieu both for writing and for accumulation of text snippets; and its interface is an outstanding example of gorgeously clean design. But it offers nothing I particularly need, thanks to tools I already have. If Z-Write had multiple levels of notes, and keywords so that you could show or hide sets of notes, it might excite me a bit more. But as it is, Z-Write is essentially just an outliner reduced to a mere single level of hierarchy. Many of Z-Write's features - such as bookmarks, glossaries, and text-munging - are present in common writing tools such as Microsoft Word and Nisus Writer; even the basic interface is reminiscent not just of EZNote's interface, but also of Word's document map feature. All this wouldn't grate on my nerves if only Z-Write's documentation didn't constantly claim uniqueness and originality, as if a "non-linear word processor" were novel (I've been writing non-linearly with outliners since my Apple II days, and reporting on non-linear writing tools in TidBITS for almost a decade). Still, Z-Write has some vocal adherents, and you should certainly try it if you think it might fill a niche in your life.
The $20 Z-Write requires a PowerPC-based machine with System 7.5 or higher, and QuickTime. It requires 10 MB of RAM (more if you're going to use the Print Preview feature) and 5 MB of disk space.
Article 8 of 21 in series
by Matt Neuburg
Storyspace, the long-standing hypertext application from Eastgate Systems, was the first program I ever reviewed for TidBITS, and I described a new version of it last yearShow full article
Storyspace, the long-standing hypertext application from Eastgate Systems, was the first program I ever reviewed for TidBITS, and I described a new version of it last year. Now Eastgate is back with a new offering, Tinderbox.
Tinderbox incorporates most of Storyspace's fundamental metaphor and interface; outwardly, the two programs are almost indistinguishable. But they are oriented quite differently. Storyspace is about hypertext narrative; it presupposes an author and an audience, and uses mechanisms such as guard fields and the freeware Storyspace Reader program to guide the audience through a non-linear narrative. Tinderbox lacks those mechanisms and introduces new ones; it is aimed at the single user, and is meant as a kind of lightweight database, a text snippet keeper, a note-taking utility, a way of organizing pieces of information and perhaps exporting them as HTML.
For me, this evolution is delightful, because it fills a need I had already felt. I got lots of mileage out of Storyspace for hypertext renderings of Greek grammar, but the program also seemed as if it could be a snippet keeper; when I tried treating it as one, I found the experience unsatisfactory. The reason is that I was misusing Storyspace; Tinderbox turns out to be what I was after all along. It deserves a place alongside the utilities for storing, organizing, and retrieving information in interesting, powerful ways that I've described in the past.
Getting Started -- (Warning: This paragraph is highly condensed; for a more complete understanding, reread my Storyspace review.) In Tinderbox, the basic entity is the text snippet, which is called a note. A note has two parts: its name, and its actual content, if any, which can be styled and can include pictures, and is edited in the note's text window. A note can be placed "inside" another note, creating a hierarchical relationship among notes; sub-notes of the same note also have an order amongst themselves, which you can rearrange. There is thus an outline-like hierarchy of notes; you can view this hierarchy in various ways, called outline view, chart view, treemap view, and map view. But notes can also relate to one another through hyperlinks; a link can emanate from a note as a whole or from a particular stretch of text within a note, and leads to another note. Following a link from where it emanates opens the text window of the note it leads to. A link can also be assigned a name.
Getting started with Tinderbox is extremely easy. If you're willing to learn just a few shortcuts, you can start brainstorming immediately, creating and entering successive notes without the mouse: Return creates a new note, Spacebar opens its text window, Command-W closes it, Enter renames it. Once you have a few notes, you can rearrange them; the easiest way is in outline view, where you can just drag or use keyboard shortcuts. Making hyperlinks is just as easy: select a note or some text in a note, type Option-Command-L, click on the link's destination. There are other ways to accomplish these actions; my point is just that you can start to work effectively right away.
To this basic bag of tricks, Tinderbox adds two major innovations: attributes and agents.
Attributes -- Attributes constitute an additional mode of snippet organization, ranking with the outline hierarchy and hyperlinks. An attribute is simply a name-value pair, where the value can be a basic type such as text, a number, or a date - for example, "age:47". Many built-in attributes exist by default, such as what font a note's title appears in; but you are also free to create new attributes. Thus Tinderbox becomes a lightweight database; for example, if every note representing a person has the person's age as an attribute, you can quickly find all persons older than a certain age.
Although notes don't actually come in different types, you can treat them as if they do: you might have "person" notes with an "age" attribute, "book" notes with an "ISBN number" attribute, and so on. In reality, every note has a value for every attribute, so a "person" will in fact have an "ISBN number"; but that doesn't matter because you won't normally encounter it. You can set a note to display particular attributes in a pane at the top of its text window; so while editing a "person" note's text, you could see his age at the top of the window, but not his ISBN number. And his ISBN number will have a default value such as zero or the empty string, so your "book" searches won't find any "person" notes.
There are many ways to view and manipulate attributes. I've already mentioned that you can display attributes at the top of a note's text window; you can edit them there too. A note's Info window displays and lets you edit all attributes of that note. A stamp is sort of the opposite: it is a particular value for a particular attribute, which you can apply to all selected notes by choosing from the Value menu or using the Quick Stamp window. A prototype is a note that acts as a template; other notes, if they're assigned this note as their prototype, inherit its attribute values. Finally, an action is an attribute assignment that's performed automatically by a note on its sub-notes at the time they become its sub-notes (whether by being created within the note or by being moved into it) - a powerful feature, obviously, to be handled with care.
Agents -- To understand agents, you need to know about aliases. A Tinderbox alias is like an alias in the Finder; you make an alias of a note and put the alias anywhere, allowing the same note to be represented in multiple locations in the hierarchy (just as in the venerable outliner MORE).
An agent is a kind of query about all the notes in your document. Now, Tinderbox already has a Find feature; so how is an agent different? Well, an agent is itself just a note, one of whose attributes is its query. The way an agent note tells you what notes satisfy its query is that it is populated with sub-notes that are aliases of those notes. This notion of searching and gathering aliases is not completely original - MORE does it, for instance - but Tinderbox's queries are more powerful than MORE's, plus the whole thing is automatic and dynamic: Tinderbox is constantly perusing your document and updating what's gathered by every agent. For example, if an agent searches for all notes whose text contains the word "Aeschylus", then if you type the word "Aeschylus" in a note, an alias to that note will suddenly appear among the sub-notes of that agent. Agents thus provide automatic simultaneous alternate groupings of your notes to help you keep track of your material.
Miscellaneous Goodies -- This section lists various neat Tinderbox features I couldn't fit in elsewhere.
Storyspace, as I've long lamented, limits note names to 32 characters. Tinderbox lifts this limit, so notes can have meaningful names, and you can use outline view as a genuine outline.
Tinderbox remembers link names globally, so to assign a link a name you've used already, you just choose it from a pop-up menu (rather than having to remember and type the name manually each time, as in Storyspace). Agents can search on link names - for example, you can search for notes linked to by a "disagrees" link - which makes such names genuinely useful.
If a word in a note's text window has internal capitalization (likeThis), then if you Command-Option-click on that word, which is normally the signal to follow a hyperlink, but there is no hyperlink, Tinderbox will attempt to treat the word as a hyperlink anyway: if the word is the name of a note, Tinderbox jumps to that note; if not, Tinderbox offers to create a note by that name. (This implicit link behavior is borrowed from the world of WikiWikiWebs.)
A note can have a file associated with it; just drag the file to a text window's file icon. A menu item lets you open the file. Tinderbox can thus be used as an organizing interface to files on disk.
Sub-notes can be kept sorted, in accordance with criteria specified in the attributes of the note to which they belong.
A convenient new view, Explorer view, works like REALbasic's code browser: on the left, notes are listed in outline, chart, or map form; on the right is displayed the text of whatever note is selected on the left.
The Tinderbox file format is XML text, so it can be studied and changed programmatically or with a text editor. I found a use for this almost immediately: halfway through writing this review (using Tinderbox, of course) I changed my mind about what font I wanted to use in all my existing notes; I couldn't find a way to make the change easily within Tinderbox, so I did it in BBEdit with a single find-and-replace command.
Web Features -- Tinderbox also has a number of Internet-oriented features. For example, a link from text can now be a link to a Web page. And Tinderbox is itself a Web client: a note can have a URL attribute, and its text will then be the text of whatever is at that URL, downloaded on demand. However, Tinderbox isn't a browser, so if the text is HTML, Tinderbox can only either display the raw HTML or have your browser show the page.
Tinderbox can also download RSS news feeds. These are XML files in a standard format, typically listing news headlines with links to further information. They're popular chiefly because they're machine-parsable, so your computer can comb the Web each day for the headlines that interest you. When Tinderbox downloads such a file, it eliminates the XML markup and other extra information, leaving just the headlines and links. The links are live, meaning you can click one to view that page in your browser. For example, if a note has TidBITS's RSS feed as its URL attribute value, and if its auto-fetch attribute is turned on, then every time you open this Tinderbox document, Tinderbox will download the RSS and you can open the note's text window to see the headlines of, and links to, our latest articles.
You can also use Tinderbox to export notes as HTML using a template, an HTML text file with placeholders for elements that are to come from each note. Links from text in a note to another note are preserved as HTML hyperlinks; the hierarchical structure of the document is preserved; and you can specify navigational links to help the user move around that structure. The template mechanism is simple but surprisingly powerful; for example, you can construct conditional template elements. Furthermore, certain details about how any individual note will be exported are set through its attributes; so, for example, all notes could use a certain template by default, but particular notes could use a different template. The export for a note can include the export of its sub-notes. And of course a template can access any attribute of a note, thus combining the lightweight database and HTML export features.
How might you use the HTML export mechanism? To make Web sites, of course! The manual invites you, for example, to envision the possibilities of exporting an agent along with its sub-notes; if the agent's query is for notes created within the last two weeks, sorted by the date of their creation, you've got a weblog. (Several Tinderbox-generated sites in weblog form have already appeared, including Eastgate's own.) Plus, the mechanism can also do XML, so you could use it, for instance, to generate RSS files and contribute to the flow of syndicated news feeds.
Good Progress -- When I first looked at Tinderbox, it was at version 1.0 and ran only in Classic. It didn't take me long to encounter a laundry list of bugs or surprising behaviors; so I shelved the product for a while, and I'm glad I did. Tinderbox is now at version 1.2, it's carbonized to run natively under Mac OS X, and it has been greatly improved in many small but significant ways.
Some of the laundry list remains, though usability is not hampered in any major way. For example, when you change an agent's query using Quick Stamp or the Info window, the agent's search results don't update, which can be confusing. The content of certain windows leaps around; for example, if you try to scroll the Locate window, it suddenly scrolls back to the current selection. There are no commands to expand or collapse fully all of a note's sub-notes in outline view.
The manual isn't bad, but it appears to have been given minimal attention in the heat of development. Some features such as sorting, RSS, the Roadmap, and wiki-style hyperlinks are not documented at all; other features, such as links to specific text, are documented as if they existed when in fact they don't. This is unfortunate, since incorrect documentation impairs one's understanding and usage of the product.
An alias accesses the text and attributes of its original, but doesn't display its sub-notes; I see no reason for this limitation (contrast MORE, or the Finder). Also, I wish text export could be performed as styled text, not just plain text as happens now; that way, Tinderbox could become a real writing tool.
Concluding Remarks -- Tinderbox is, as I hope I've implied, an inspired piece of work. With its Web capabilities, outliner hierarchy, hyperlinks, lightweight database abilities, and snippet keeping, Tinderbox will surely have something to intrigue you. It's small, it's easy, it's fascinating, and it's cool. I strongly recommend that you download the demo and see for yourself. You may not understand the program fully at first, but keep experimenting; this is a powerful program with many uses, and the possibilities will start to dawn on you as you work with it.
Tinderbox costs $145. For the Mac OS X version, Eastgate recommends Jaguar. The Classic version needs 16 MB of RAM; Mac OS 9.0 and a recent version of CarbonLib are required, with Mac OS 9.2 recommended. The demo is a 2.7 MB download.
PayBITS: Did this review introduce you to software you might use?
Consider sending Matt a few bucks to show your appreciation!
Read more about PayBITS: <http://www.tidbits.com/paybits/>
Article 9 of 21 in series
by Matt Neuburg
What's in your digital shoebox? You know, the place where you stash those pesky snippets of pure text, be they a few words or many paragraphs, snippets that you know you'll need later but you just can't categorizeShow full article
What's in your digital shoebox? You know, the place where you stash those pesky snippets of pure text, be they a few words or many paragraphs, snippets that you know you'll need later but you just can't categorize. A database would be overkill; an outliner's hierarchy would be useless. So you just toss them into a virtual pile, a deliberate mass of miscellaneous clutter - a digital shoebox.
Here's some of what's in mine: Tips on what certain Mac OS X keyboard commands do; some Unix phrases I need to utter in the Terminal now and then; someone's opinion of what router to buy, copied from a Usenet newsgroup; directions to my house, fit for emailing to visitors; the URL of something I'm selling on eBay; and my vacuum cleaner model number. How miscellaneous can you get? Yet I can lay my hands on any of them instantly.
Now, I am, as you know, hopelessly obsessed with storage and retrieval of information. I like hierarchies, hyperlinks, keywords, and categories. A digital shoebox is the opposite of all those things! Nevertheless, there are times when simpler is better; and the excellence of a true digital shoebox is to be really, really simple. In fact, there seem to be just two main requirements for good shoebox-hood: a very plain interface and a very fast Find.
My digital shoebox is currently iData Pro, from Casady & Greene. This program has a venerable lineage, having appeared under such previous names as InfoGenie and QuickDex. How venerable? Well, QuickDex was a desk accessory, if you remember what those were, and my research trail, which shows that it had a vociferous cult following, turned up the fact that it was first released in 1987. Let's just say that iData Pro is a Mac OS X incarnation of a very old favorite.
The main reason iData Pro meets the requirements for shoebox excellence is that its files are just text, nothing more. One font, size, and style apply to each file when it displays. The only unusual feature of the file is the ASCII 06 control character used to separate entries. If iData Pro went on the fritz tomorrow, all my data would still be sitting there, plain as day, perfectly legible in BBEdit or Microsoft Word. And when a file opens, the whole thing loads into memory, so searching for specific text is extremely fast.
Free-form Files -- iData Pro can make two kinds of files; you specify which you want when you create a file. The first, and most shoebox-like, is the free-form file. What you see when you look at a free-form file is the text of one entry, and that's all - the entry has no title, no keywords, no identifying marks of any kind other than its content. There is also a Find field at the top of the window. The entry content area is a decent text editor. Keyboard navigation and selection, and drag & drop, all work as expected. Option-Tab jumps between the Find field and the entry content area.
In this window, you can add a new entry, or delete the current entry. You can navigate to the next or previous entry, or the first or last entry; but mostly you won't do that except to get an overall sense of what's in the file. Instead you'll navigate by finding: In the Find field, you'll type a word and hit Return to jump to its next occurrence in the file, in the same or another entry. One is reminded (and I'm not the first to make this comparison) of navigation and finding in HyperCard.
That's basically all there is to it. You add an entry, enter some text, and return to it later by remembering some word within that text. In practice you'll probably use your knowledge of your own mental processes to make sure the text contains words you're likely to think of when seeking it later. For example, when I pasted in the opinion about a good router, I deliberately typed "opinion about good router" at the start of the entry, because the word "router," which I would expect to search on later, didn't occur in the pasted material.
The fact that you see just one entry at a time, by the way, is not generally problematic. You can open a second (read-only) copy of a file, letting you see two entries at once. Also, instead of finding successively, you can winnow the set of currently available entries (called "selecting"); subsequent selecting can be from the currently selected set of entries or from its inverse. Thus, one way or another, you'll have a pretty good sense of what's in a file, and you can narrow in on the entry or entries you're looking for quickly and easily.
Field-Based File -- A field-based file looks a little different from a free-form file: every entry consists of several named fields. When you create a field-based file, you declare these field names. (Don't worry; the names and order of the fields can be changed later, fields can be added and removed, and so forth.) There is thus some superficial similarity to a flat file database, but this similarity really is superficial, since ultimately there's no difference between iData Pro's two file types. The difference lies in how you're shown the text of the file; in a field-based file, each paragraph is portrayed as a separate field. Thus, no field can consist of multiple paragraphs except the last one.
How does a field-based file's window, and what you can do there, differ from a free-form file? First of all, the field names appear down the left side of the window. You can tab from field to field, entering or modifying text. Also, you can switch the window to a "list view," a grid of cells with each row representing one entry and each column representing one field; you can specify that certain fields shouldn't appear in list view. You can do a Find or Select that looks in just one particular field. And you can sort on one or two fields; you can sort a free-form file too, but less powerfully, and you're less likely to want to. (Actually, even in a free-form file, if entries have a consistent structure, you can use that structure to some extent when sorting and selecting.)
What are some candidates for a field-based file? An address book (last name, first name, address, address line 2, phone number, and so on) is an obvious example. The first field-based file I actually made was a holiday gift list; the fields were the person, the gift, whether I'd bought it yet, whether I'd sent it yet, and a notes field (a common use for the last field, because it can have multiple paragraphs). It would have been possible to use a more powerful program for this purpose - a database, or a spreadsheet - but for something so basic, iData Pro's simplicity was perfect.
Other Features -- If all your files live in the same place, they all appear in a special menu (the Datafiles menu), from which you can open any of them. Files thus become a level of categorization within the total mass of your data. Also, particular files can be set to open automatically whenever you start up iData Pro, so that your most commonly needed data is always accessible.
You can export and import data. Mostly you'll use tab-delimited format, but iData Pro also knows about the format of some common email programs and can import entire mailboxes. Also, iData Pro has a built-in notion of extracting an address, so that if you have, say, a field-based address book file, you can dictate how to assemble the various fields to make an address. Even more important, iData Pro is scriptable, so this behavior, as well as other tasks, can be even more precisely customized.
iData Pro can dial a selected phone number, through your modem, in various ways that you can configure; indeed, the program turns out to be extraordinarily good at this. You can print labels and envelopes, using templates that you can configure. Email addresses and Web URLs can be live links, so that clicking them creates an email message or goes to a Web page in your preferred helper application. There's also hot-syncing to your PDA, but I don't have a Palm to test this.
Conclusions -- iData Pro does have some irksome shortcomings, having mostly to do with how it has been ported to Mac OS X. For example, its windows don't respond to my mouse's scroll wheel, making it just about my only remaining program with this problem. Also, iData Pro's notion of text is unnecessarily primitive; it knows nothing whatever of the rich Unicode world that surrounds it, and can't access more than the first 230-odd characters of whatever font is used to display a file. To rewrite so simple a program in Cocoa, as a true Mac OS X native application, wouldn't be difficult, and I hope that Casady & Greene will eventually do so. At least the program is actively supported; there's a good bulletin board hosted at the developer's site, and bug fix releases appear quite regularly.
iData Pro costs $40, with competitive upgrades from various other organizer and database programs for $30. A free demo version is available for download.
PayBITS: Did Matt's review of iData Pro help you organize
your important information? Consider thanking him via PayBITS!
Read more about PayBITS: <http://www.tidbits.com/paybits/>
Article 10 of 21 in series
by Matt Neuburg
In our perpetual journey towards better ways of storing and retrieving information, a simple text-snippet keeper like iData Pro, discussed in TidBITS-675, was merely a side trip to a simple, restful poolShow full article
In our perpetual journey towards better ways of storing and retrieving information, a simple text-snippet keeper like iData Pro, discussed in TidBITS-675, was merely a side trip to a simple, restful pool. Now we rejoin the main trail, clambering up the slippery Relationship Rocks beside the pounding falls of Content Cascade, ascending the heights to survey in one massive view all the surrounding countryside of hierarchies, hyperlinks, keywords, to-do lists, and snippets of every kind.
As you can tell from the extended metaphor of the previous paragraph, I'm excited. And what I'm excited about is a Mac OS X program called NoteTaker, from AquaMinds. NoteTaker is an outliner, a writing tool, a categorizer, a snippet keeper, a presentation tool, a Web site maker. It can organize your thoughts, your files, your life. Its potential seems vast, and everyone will use it differently. Remember the feeling of wild surmise when you first mentally glimpsed the possibilities of HyperCard or Apple events? NoteTaker is like that.
NoteTaker is a descendant of a NeXT original called Notebook; and as an added complication, it isn't the only one! Another descendant, NoteBook from Circus Ponies Software, made its debut just as I was finishing this article. I'm sure there's one heck of a story here, but this article won't be about that, and it won't compare the two products. I started using NoteTaker first, and that's what this article will describe.
Outline -- NoteTaker is an outliner, so let's start by reviewing what an outline is. An outline is a way of arranging pieces of text not just linearly but also hierarchically for ease of viewing, rearrangement, and retrieval. Each piece (called an "entry" in NoteTaker) is either at the top level or subordinate to some other entry. An entry's subentries can be hidden ("collapsed"); this makes it easy to view as much or as little of the outline as needed at the moment. If you move an entry - by cut-and-paste or by dragging - all its subentries travel with it.
NoteTaker as an outliner is pretty good, though still not as good as MORE, the gold standard. For example, it lacks promote and demote features. It doesn't behave as conveniently as MORE when you create a new entry. Until recently, it didn't even have a keyboard command for moving an entry up or down. Navigation and manipulation of entries are now implemented fairly well, but since NoteTaker is explicitly inspired by ThinkTank (MORE in its earliest form), one would hope for a better appreciation and implementation of its virtues.
A NoteTaker entry can consist of multiple paragraphs, and you can easily split an entry into two (though you cannot merge two entries into one, as in MORE). These paragraphs can have formatting - tab stops, justification, line spacing (again, like MORE). NoteTaker lacks MORE's superb system of "rules," which rationalizes such formatting on an outline-level basis; but it has the built-in Cocoa capability to copy and paste paragraph formatting. And every paragraph of a multi-paragraph entry has its own formatting; thus, NoteTaker doesn't need MORE's distinction between "topics" and "paragraphs," since an entry consists of paragraphs already.
In fact, NoteTaker will accept just about anything as an entry. You can paste in styled text or a picture. Drag in an Address Book entry: NoteTaker will parse it into an outline. You can draw directly into NoteTaker using Inkwell. You can even record a voice message, directly within NoteTaker; it's saved as an MP3 file as part of the document.
Links -- An entry can be a hyperlink to another entry, in the same or another NoteTaker document. To make a link, select the first entry and choose Link To Entry; a floating palette appears. Now go to the second entry, select it, and click the Link button on that palette. The first entry is now marked as being the source of a link; click the button to its left and you navigate instantly to the second entry. The only downside is that an entry that is a link must not have any subentries, a rather silly limitation.
Links also allow your document to relate to the world around it, meaning other files on disk as well as the Internet. An email address or a Web URL is automatically recognized; click it to send the URL to your preferred email program or Web browser. If an entry is a Web URL, you can even view the page's content rendered right within NoteTaker, provided it's a fairly simple page.
Drag a file from the Finder into a NoteTaker document, and you've got a link to it (though NoteTaker stores the link as an absolute path, so if you move the file in the Finder, NoteTaker loses track of it). In many cases, this link is displayed with extra information. If it's an image file or single-page PDF, you see the image. If it's a movie file, you can play the movie. If it's a sound file, you can play the sound. And in any case, you've got a link to a file on disk, which you can treat as if you were in the Finder: you can open it, you can drag it to the Finder to make a copy, and you can Option-Command-drag it to the Finder to make an alias. If you hold down the Option key as you drag a file into NoteTaker, it is copied right into your document (and is then called an "attachment"); this is possible because a NoteTaker document is a package, a folder that looks like a file. Thus you could use a NoteTaker document as a kind of suitcase, storing other files of all sorts.
Marks and Categories -- You can mark an entry in various ways. For example, there's a mark called Flag; an entry is either flagged or it isn't. There's a Command key shortcut to toggle an entry's flagged state; alternatively, in some situations you can double-click to the entry's left. Whether or not an entry's flagged state is visibly expressed is up to you. To the left of every entry is an area where you can show or hide any of several columns. If you choose to show the Category Icons column, a flagged entry has a checkmark in that column. An obvious use for this would be as a to-do list: when you've performed an item, flag it so that it has a checkmark. But even without being visible, marks can be useful; for example, there's a way of searching for them.
The second type of mark is called Priority. You get three priorities: Low, Medium, and High (or None). If you mark an entry as having a priority, then if you show the Priorities column, you see an L, M, or H in that column. Again, this could be useful for a to-do list, and again, you can search by priority.
A third type of mark is the Date. Every entry is assigned the current date on creation, and the date when it was last changed is maintained as well. You can also set either of an entry's dates manually; that date then stops updating automatically, so you can associate dates with entries in whatever way you like. You can see either set of dates by showing the Date column, and you can search by date.
Things start to get hot with the fourth type of mark, the Category. This is simply a keyword; that is to say, it cannot be any old word, but must be chosen from a list maintained at document level. Every document comes with some built-in categories, but you also get to define your own. If you show the Categories column, you see the category assigned to each entry. An entry cannot have more than one category, and like the other columns, you can search by category.
Under certain circumstances, NoteTaker assigns categories to entries on creation. For example, if you drag an image file into a NoteTaker document, the resulting entry is assigned to the Image category. If you drag in an Address Book item, the resulting entries are each assigned a category corresponding to their original Address Book field: Full Name, Email, X-Aim, and so forth.
Categories become even more powerful in conjunction with Templates. A template is simply boilerplate, letting you insert often-used information rapidly into your document. Such boilerplate can consist of a hierarchy of entries (possibly empty) with categories. This is NoteTaker's equivalent of WebArranger's wonderful capability to let an outline entry be a specific kind of entity with the fields appropriate to that entity.
For example, let's say you want to maintain a list of your friends and their favorite flavors of ice cream. You would define a category Friend and a category Ice Cream, make two empty entries where one is a subentry of the other, assign one entry to the Friend category and the other to the Ice Cream category, and turn them into a template. Now, at any time you can insert that template anywhere in a NoteTaker document, and presto, there's a blank Friend with a blank Ice Cream subentry, ready for you to fill in the data. NoteTaker comes with one template, Contact, which inserts categories like Name, Address, Phone, and Email, so any document can be used as a contact manager right away.
Pages and Sections -- A NoteTaker document as a whole is based on a notebook metaphor. It consists of multiple outlines; every outline is a page of the notebook. Every page that you create consists of a new outline, and you can give the page a title. Pages are clumped into sections; you can create a new section, and you can give it a title. The section titles may be viewed as tabs sticking out the side or bottom of the document, and you can click a tab to navigate instantly to the start of that section. Individual pages can optionally have tabs too - useful if you must navigate frequently to particular pages. Keyboard shortcuts let you navigate to the first, last, next, or previous page or section. Plus, from any page you can save a "page mark" file, which is essentially a bookmark, a link that lets you navigate instantly from anywhere (meaning the Finder or another NoteTaker document) to that page of that document.
Now, you might say that pages and sections are really just outline entries in another guise: they merely add another couple of levels of hierarchy to the organization of the outline. That's true, but it doesn't mean they're just fluff. It's useful not to have to deal with all your information at once. True, an outline is collapsible, and many outliners (including NoteTaker) let you temporarily hide those parts you're not interested in; but even so, a multi-outline document sometimes feels better than one big outline. It's nice to be able to put some kinds of information off on a page of their own, where you don't have to come in contact with them until you need them; for example, rather than interspersing images with text in an outline, you could have a page of images, and link from the text to the relevant image.
The metaphor of pages and sections leads to the further metaphor of tables of contents. NoteTaker creates and maintains these for you automatically. The first page of any NoteTaker document is a complete table of contents, listing every section and page; the first page of any section is a table of contents listing every page of that section. The entries here are links, so you can navigate to any section or page instantly. (Unfortunately there's no keyboard command to navigate directly to the table of contents for the section you're currently in.) To rearrange pages or sections, you move the entries in a table of contents.
Hunting and Gathering -- You can find things in various ways. First, there's a normal word-processor find, which just cycles through the document looking for the next occurrence of a given bit of text.
Second, there's a global search, which finds by text, by flagging, by category, by priority, and by date. The results of a global search can be perused in two different ways. All found entries can simply be highlighted (marked in yellow), and you can cycle through the document from one highlighted entry to the next. Alternatively, found entries can be copied; a Summary section is created at the end of your document, and the copies are placed in a new page there. The whole feature is strongly reminiscent of MORE's Mark and Gather; the NoteTaker name for it, Highlight and Summarize, even says the same thing in different terms. Unfortunately the gathered copies are not links, so there is no way to relate what was found to the document itself.
Third, your document can have an Index section. This appears instantly when you ask for it, so I suspect that it is constantly being maintained behind the scenes even if your document isn't showing it. Each page of the Index is an outline consisting of links to entries of your document, filtered and clumped in different ways. There's a page of links by priority (that is, a link to each low-priority entry, then a link to each medium-priority entry, then a link to each high-priority entry). There's a page of links by category. There's a page of links to all email addresses and Web sites in your document. There's a page of links by date. There's a page of links to every entry that's a document link, arranged by file extension. And there's a word index - that's right, every word of your document is indexed! Unfortunately what you're shown here is a page number, not a context, so finding the passage you were looking for can be rather clumsy.
What's Doing -- Although I've used a to-do list as an example of how you might use certain NoteTaker features, you don't have to implement this yourself, because NoteTaker does it for you. You ask for a To Do Section, and a section is created which has some magical properties: every day, a new page is created and titled with that day's date, and all unflagged entries from the previous day's page are copied to it. Thus you have an ongoing daily list of tasks. Of course, you could also deliberately misuse this feature as a diary - take advantage of the automatic daily new page, and flag each day's entry so it isn't copied to the next.
Pathways In and Out -- NoteTaker provides a number of ways to move information into and out of a document (besides cutting and pasting, of course). For getting information in, the most impressive is the Clipping Service. From any page in a NoteTaker document, you choose a menu item called Create Clipping Service. Now you can close the document and even quit NoteTaker if you like; the Service you've created exists independently (in your ~/Library/Services folder). In any application that can see Mac OS X services, an item appears in the Services submenu of the application menu; choose it, and the currently selected text is copied into that page of that NoteTaker document. Since Carbon applications mostly don't see the Services menu, AquaMinds also provides a contextual menu item that accesses the same functionality. They describe this as a beta, but it seems to work decently everywhere I've tried it.
You can also create a search service, which allows you, in some other application, to look for selected text in a particular NoteTaker document. If the text is found but isn't the occurrence you wanted, you can repeat this action to look for the next occurrence, or just stay in NoteTaker and do the rest of your searching there.
You can view your document as a "slide show," which is really just your same document seen in full-screen mode; there are no scrollbars, so pages need to be short, but everything else works, including links, QuickTime movies, and so forth, so you could use a NoteTaker document as the basis of a multimedia presentation.
Let's Get Personal -- You might be curious about how I use NoteTaker. In part I use it just as a Mac OS X-native version of MORE, to plan and take notes on books I'm hoping to write, to compose talks, and so forth. But that doesn't really take advantage of NoteTaker's special powers. More interesting is how I used it to structure and track my activity while I was doing some custom Cocoa programming for a corporate client. As a feature specification or bug report would arrive from the client, I would drop it into its own NoteTaker page, along with any screen shots or other ancillary material. Then I'd go to the main page of my document, which functioned as a to-do list. Here I'd create an entry describing the problem, along with subentries containing my musings on how to proceed, plus a link to the page where the material from the client was stored. I assigned the main entry to the To Do category, gave it a priority, and showed its creation date. I continued the same procedure as I discussed the matter with the client, making additional notes of my own thinking, and often pasting entire email messages into the ancillary pages; thus I had an easily searched record of the whole conversation, tracing the evolution of the spec, so that I could prove later on, if necessary, that what I had done was what we had agreed upon. When I felt clear on how to proceed on an item, I gave it a subentry assigned to the Resolution category and described my decision. When the task was done, I removed its priority and flagged it, and added a subentry assigned to the Done category so that the date was recorded. In this way I knew at all times what most urgently needed working on and what the state of my thinking was on each task, plus I had complete documentation of the discussion, evolution and resolution of each item.
A Final Note -- NoteTaker's manual is rudimentary, vague, and anecdotal. The program has some AppleScript support; you can crash it by saying the wrong thing to it, but once you get the hang of things you can do quite a bit through scripting. In general, NoteTaker works pretty reliably and has a good Undo implementation, but things can go wrong, so do take advantage of its auto-save and auto-backup features.
NoteTaker is being actively developed, and many improvements will probably be appearing in future versions. If you're intrigued by NoteTaker's possibilities, now is a great time to try it out; the sooner you start bending it to your own purposes, the sooner you can provide feedback that will help shape its evolution.
NoteTaker costs $70, or $40 academic. A thirty-day demo is available as a 5.3 MB download.
PayBITS: Did Matt's review of NoteTaker help you organize
your important information? Consider thanking him via PayBITS!
Read more about PayBITS: <http://www.tidbits.com/paybits/>
Article 11 of 21 in series
by Matt Neuburg
Back in 2001, after I'd written several TidBITS articles about intriguing ways to store and retrieve information on your Mac, a number of readers attempted to impress upon me that for some folks, simpler is betterShow full article
Back in 2001, after I'd written several TidBITS articles about intriguing ways to store and retrieve information on your Mac, a number of readers attempted to impress upon me that for some folks, simpler is better. It was with that in mind that I wrote "Three Simple Snippet Keepers" in TidBITS-593. And later, in the same spirit, I discussed iData Pro X, hinting that perhaps it was a bit too simple, since its notes were just text, with no fonts, styling, or Unicode awareness (see "The Digital Shoebox: iData Pro X 1.0.5" in TidBITS-675; also see the series "Two Bytes of the Cherry: Unicode and Mac OS X" for more on Unicode). It was in reaction to that article that a reader wrote suggesting that some users were quietly but enthusiastically practicing the cult of Hog Bay Notebook, and that I should be looking into this.
Hog Bay Notebook, which recently reached version 2.0.1, certainly is worth looking into. It is indeed simple - you can learn to use it in about a minute - and has an elegance and visual clarity that is simply stunning. At the same time, it's powerful, mostly because it has an amazing search engine build into it. If you have snippets of information and you want to give them a modicum of organization and incredible searchability, Hog Bay Notebook might be the solution.
Taking Note -- The essence of a Hog Bay Notebook document is the note, which is exactly like a TextEdit document. You can give it a title, enter text, and add character formatting and paragraph formatting, including alignment, line spacing, paragraph margins, and tabs, by means of a ruler, just as in TextEdit. You can paste in pictures, and even drag in other documents, such as PDFs or HTML files, to be stored inside the note as an attachment. (If you didn't know TextEdit could do all those things, you haven't been playing with your computer enough!)
In fact, Hog Bay Notebook notes are TextEdit documents. Hog Bay Notebook's documents are bundles, and its notes are .rtfd files, which are one of TextEdit's native types. Indeed, if Hog Bay Notebook vanished from the universe tomorrow, you could open a document with Show Package Contents, and presto, there are your all notes, safe and warm, ready to be opened by TextEdit. All that would be missing is their titles; but these are stored in an XML document that any text editor can read. This structure adds to your sense of confidence and security when you use Hog Bay Notebook.
Getting Organized -- Notes themselves can be further organized within your document. If you like, you can create virtual folders in your document and put notes (or folders, of course) into them. The resulting hierarchy is displayed in an outline view. You may also set a few attributes of each note: a status, done or not done, which appears a checkbox; a label, which appears as a color (as in the Mac OS 9 Finder); and a rating of 1 to 5, which appears as a row of stars. The attributes are displayed in a table view of your note titles, where you can sort on any column.
Hog Bay Notebook also provides a couple of organizational extras. Selected text can be highlighted, and you can then jump from highlight to highlight within a note (but not through the document as a whole, which is a pity). And you can make wiki-style links: any capitalized word with inner capitalization, LikeThis, is taken to be the name of another note, and you can jump to that note, or create it, by clicking on that word. Also, you can navigate backwards to recently viewed notes, as in a Web browser.
Seeking and Finding -- Hog Bay Notebook's tour de force is its inclusion of a free, open source, search engine, Lucene, which does a live batch search of your entire document while you type into the search field at the top of the window. The results appear in the table view, showing each matching note's title and a bar whose length ranks the quality of the match. By default you're doing a whole-word search, but you can do partial-word and wildcard searches, boolean searches, phrase searches, proximity searches, and even weighted searches. To keep things simple, titles are automatically included in the searched material. This magic depends upon an index, of course, which is maintained live and adds somewhat to the size of your document.
In an attempt to push Hog Bay Notebook to its limits, I imported my entire diary into it - over 3,000 notes. Hog Bay Notebook wasn't fazed. I did unearth one bug: in the table and outline views, note titles stop appearing beyond some number of titles; but you can work around this by clumping your notes into folders. Everything else - the search engine, sorting, navigating, opening and closing a document - was as fast as if had been just one note - namely instant.
Taking Stock -- I did run into a couple of little issues. Hog Bay Notebook isn't at all scriptable with AppleScript, which is a pity. You can't customize the names and colors of the labels. Selecting a note in the outline view displays it, but doesn't also show it in the table view, so I don't understand how you are supposed to find out what attributes it has (its status, label, and rating). And you can't navigate from a note to its folder - when you're reading a note, you have no way to know where in the hierarchy it lives - which seems to me like an oversight.
As weighed against this, however, one can only be astounded by how clean and compelling Hog Bay Notebook's interface is. It's a kind of poster child for Cocoa, taking advantage of what seems like every widget and every technology Cocoa provides. The outline appears in a drawer. The table appears in a split view, where the split can be horizontal or vertical. You can edit a note in its half of the split view or in a separate window. The clipboard contents in another application can be pasted into a Notebook without switching to it, through the application's Dock menu; selected text can be copied in through a Service. There's spell checking, which can be inline, and a note can read itself aloud. It has a Finder-like toolbar you can collapse or customize to display text, small icons, or large icons. In fact, things are customizable to a fare-thee-well, plus there's extensive Undo. It's as if the author's intent were to give every Cocoa feature a workout.
It would be wrong, though, to give the impression that Hog Bay Notebook is a mere Cocoa kitchen sink. It's not like a Liszt tone poem; it's more like a Mozart symphony. The interface is clean, clear, well-behaved, with a sense of rightness throughout. To the user, it seems easy, obvious, light as a feather - but if you have some Cocoa programming experience, you know that, behind the scenes, this apparent artlessness is not at all easily achieved. What's really impressive here is Hog Bay's evident thorough dedication to doing Cocoa right. This, too, gives the user confidence that, with Hog Bay Notebook, your snippets are safe.
Hog Bay Notebook costs $20 shareware, and is available as a 700K download.
PayBITS: Did Matt's review of Hog Bay Notebook help you organize
your important information? Consider thanking him via PayBITS!
Read more about PayBITS: <http://www.tidbits.com/paybits/>
Article 12 of 21 in series
by Matt Neuburg
In case you've forgotten what a snippet keeper is or why you might need one, here's a case in point. Last week, a note appeared on TidBITS Talk, containing three URLs pointing to Web pages with information I found especially valuableShow full article
In case you've forgotten what a snippet keeper is or why you might need one, here's a case in point. Last week, a note appeared on TidBITS Talk, containing three URLs pointing to Web pages with information I found especially valuable. (It was an explanation of how the precise DOCTYPE specification in your HTML affects whether a browser displays that page in a standards-compliant manner.) Instantly, I wanted to save this information; it was too technical to remember, but I could easily picture myself wanting it for reference later.
Unfortunately I could also easily picture myself having no idea where I put this information, what form it was in, what I had called it, or even what precisely it was about. So how was I going to store it so as to be able to find it again? I could save the Web pages as URLs, HTML, PDFs, or Web archives, and keep them on my hard disk. But, you know, I can never really find documents on my hard disk when I need them. Folder and file names alone never lead me to the desired information - especially when I can't remember what folders I have or how I arranged them in the first place. Another problem is that even if I stumble across the right document, I don't necessarily realize this, because I can't see inside it unless I open it. But it's a big pain to open lots of documents or URLs while slogging through my hard disk, and besides, I can have a document open in front of me and still not realize it's the right one!
From this example, four lessons emerge.
A hierarchy is good, because it groups related things; but it's not enough, because you can't anticipate what circuitous path of association your brain will be using later when you're hunting for something. There needs to be some other way to locate the desired article based on whatever sense of its subject matter occurs to you at the time.
The storage needs to accept any kind of entity, like the Finder. It can't be confined to a single type of entity because the information might not come in that form.
One must be able to see a document's contents directly, without bothering to open it separately. Internet integration would be nice too, since (as in this case) information often comes in the form of Web pages.
The storage needs to be central - a single, certain place where you go any time your mind says, "I think we've got something about that somewhere..."
Enter DEVONthink, a program that understands the problem and proposes itself as the solution.
The View from Here -- DEVONthink's interface is extremely clean and intuitive, and calls for very little comment or explanation. The window displays a database, which is initially empty. To this database, you add entries - you can think of these entries as "documents," and originally for the most part they really are documents, which you'll probably just drag in from the Finder. You can also create "groups," which look and behave like folders. So your database is a hierarchy, which you can arrange freely, just as in the Finder. You can clone a document, so that more than one entry appears for it; thus, the same document can be part of more than one group.
Viewing the overall structure of your database is much like looking at the Finder; the interface includes a list view, an icon view, and a column view. But you can also view the contents of an individual document directly within DEVONthink; a two-pane view lists your overall database in one pane and the contents of the currently selected document in the other, or you can double-click a document's listing to display its contents in a separate window. If a document is HTML or a URL, DEVONthink displays it as a Web browser would. If a document is plain text or RTF, you can not only view but also edit it within DEVONthink.
Ways of Finding -- DEVONthink knows you're going to want to find a document by way of its subject matter, and its solution is to word-index your data. So, on the one hand, you've arranged your documents within a hierarchy of groups, but at the same time, at the level of individual words, DEVONthink cuts across this hierarchy to facilitate searching.
Thus, you can search by a word or words. Multiple words can be combined by AND or OR; you can search on a phrase; you can search in the contents of documents or in their titles, or even in a comment field. You can search globally or in one group. Matches can be exact or "fuzzy." Results appear instantly when you hit the Search button, and are ranked by a relevancy score.
If your initial word search doesn't prove helpful, you can generate a list of words similar to a search term, based on spelling. DEVONthink knows all the words in all your documents, so this list is generated based on that knowledge. For instance, in my database, "program" led to "programs", "programmer", "programming", "programmed", and "programmers" - basically, it got the right answer. You can then combine these new terms as desired to form a new search.
You can also generate a list of similar words based on context. This apparently comprises words used many times in documents where your original word was used many times, and the results can be really bizarre. For example, starting with "program", my first context-similar word was "clrc", because this (an abbreviation for California Law Revision Commission) happens to occur 28 times in a document where "program" occurs 24 times. In fact, all my words contextually similar to "program" were from this one document; removing it from the database resulted in a much greater (but still bizarre) diversity. The algorithm behind this feature could use some tweaking, I think (though I'm told it gets better as the database gets larger).
You can also do some powerful searches starting with an individual document. First, you can get a list of all the words in that document; you can sort this list by frequency, length, or "weight" (apparently an expression of combined length and rarity), and, of course, you can search instantly on any of those words. However, if your intention is to find documents related to this one, you are more likely to consult the list of this document's "keywords"; these are the highest-weighted words for this document that are also found in other documents, and again you can instantly search on one of them.
Alternatively, you can ask for a list of documents that DEVONthink itself considers most similar to the current document. I don't know how DEVONthink draws its conclusions in this matter, and the results are often surprising, but they do typically include at least some documents that are genuinely related.
By the same token, you can ask DEVONthink to "classify" a document: that is, to list the groups whose documents it considers most similar to this document. If you really trust DEVONthink's ranking here, you can even "auto-classify" a document, causing it to be moved directly into the most similar group; in fact, a preference lets you tell DEVONthink to do this automatically upon import of a document. The manual advises that comparison and classification are improved if you spend some time early on arranging documents into meaningful groups.
What Goes In -- For DEVONthink to search on a document's contents, it must be in a format from which words can be extracted. Such formats include plain text, RTF, HTML, PDF (which DEVONthink parses using pdftotext, or TextLightning if you have it), and even Microsoft Word files (now that Panther natively converts these to RTF).
But you can also use DEVONthink to work with a document that's not in one of these formats. Any file can be handed to DEVONthink, which, if it can't parse the document as text, simply maintains a link to the original on disk. DEVONthink can display images and movies, and play MP3s; but even if it can't display a document's contents directly, it can reveal or open the original in the Finder.
Why would you want your database to include links to documents that DEVONthink can't index or display? Well, for one thing, you might want to take advantage of DEVONthink's hierarchical file groupings; for example, if you have some text files and an Excel spreadsheet that somehow relates to them, you might want to be reminded about the spreadsheet when you're looking at the group where the text files live. But also, when a document is just a link to a file on disk, you are free to create text for that document's entry within DEVONthink; that text, which might describe the contents of the real document, is indexed and can be searched on.
What It Goes Into -- DEVONthink uses just one database. This is a pity; I much prefer an architecture with different databases for different purposes, rather than having to lump together completely disparate material that I would never need to search simultaneously.
Another thing I don't like about the database is that it does not consist solely of a word-index: if DEVONthink can index a document, it imports the whole document. There are two problems with this: size and security. A DEVONthink database, at least in my tests, proves to be about twice the size of the text files that constitute it. This means that if I don't jettison the originals after importing them into DEVONthink, I'm using three times the disk space. But if I do jettison the originals, my data exists only in a proprietary binary format from which it cannot be recovered if DEVONthink some day goes on the fritz.
DEVONthink does let you export an imported document, and this seems to work (for example, file type and creator, as well as modification and creation dates, are maintained); so for extra security you could periodically export the whole database, thus regenerating Finder copies of the original documents. Nonetheless, I find the single-database architecture combined with the large database size and its proprietary format to be a significant deterrent to the use of DEVONthink; perhaps we'll see a future version that will address these issues.
Shortcomings -- On the whole, DEVONthink seems extremely well written; I have not seen it crash or otherwise seriously misbehave in such a way as to undermine confidence. Nevertheless, during testing I rapidly encountered a number of limitations that seemed to me unnecessary and easily fixed.
In a multi-word search, complex boolean expressions are not possible: either all the words are related by AND or they are all related by OR; similarly, you can search by content or by title but not both at once. Most database views are hierarchical, but there are no hierarchical navigation shortcuts; for instance there's no command to move the selection hierarchically upwards. DEVONthink acts as a Web browser, but there are no buttons or shortcuts for Back and Forward (there are contextual menu items, but that's a non-standard, inconvenient approach). An image document can be displayed within DEVONthink or can have editable text, but not both. There is no convenient way to launch URLs in plain text documents. When auto-classifying, there is no way to learn where DEVONthink put the document (it just vanishes and you don't know where it went). There is no way to locate all the clones of a document.
DEVONthink is also riddled, quite unnecessarily, with jargon. Menu item commands are sometimes incomprehensible, and you have to resort to the manual to learn what they mean. What do you make of "Delete" vs. "Destroy"? What do you suppose "Touch" does? How does a document's "Path" differ from its "URL"? (Hint: it has to do with the difference between "Opening" a document and "Launching" it.) Sometimes terminology is downright incorrect: "Toggle Outline" doesn't change anything about outlining (it shows or hides a checkbox); "Replicate" and "Replicant" are used instead of "Clone" or "Alias"; "Concordance" doesn't display a concordance (it displays a word list, which is a very different thing - a concordance involves context).
The manual is a PDF without bookmarks; the online help is exactly the same content in an almost useless format (a main table of contents page and a mass of subpages containing no links whatever). It is, in places, inaccurate, outdated, incomplete, and often not quite English.
Conclusions -- DEVONthink is a program I'd love to love. I don't, quite; the database architecture vexes me, and the shortcomings listed above, while in many ways minor, are the sort of oversights that surprise me in a program that's a couple of years old and is now at version 1.8. Still, there's no doubt DEVONthink is on the right track. And I'm told that there are already plans to address most of these issues in future versions of the program - some as soon as 1.8.1, which could emerge any day now.
Perhaps you remember my review of Boswell, and my complaints about it: it stores text only, it doesn't store aliases, you can't delete or edit a stored snippet, the interface is clumsy, it's too expensive. DEVONthink answers all of those objections and more: it's what I wanted to see in Boswell. DEVONthink is inexpensive, flexible, easy, intuitive; it features straightforward arranging and fast, powerful searching; it lets you edit snippets; it stores links to files on disk. In the interests of space, I haven't done justice to all DEVONthink's capabilities, so for the full story, you'll just have to download it and see for yourself.
DEVONthink requires Mac OS X 10.2 Jaguar or higher and costs $35. A demo is available as a 3 MB download.
PayBITS: Did Matt's review shine the light of searchable clarity
into the murky corners of your hard disk? Send him a few bucks!
Read more about PayBITS: <http://www.tidbits.com/paybits/>
Article 13 of 21 in series
Normally, Matt Neuburg looks at all the text management and snippet keeping utilities for TidBITS, but back when AquaMinds' NoteTaker and Circus Ponies' NoteBook were coming out, he dove into NoteTaker (see "Take Note of NoteTaker" in TidBITS-677) and I opted to take a look at NoteBookShow full article
Normally, Matt Neuburg looks at all the text management and snippet keeping utilities for TidBITS, but back when AquaMinds' NoteTaker and Circus Ponies' NoteBook were coming out, he dove into NoteTaker (see "Take Note of NoteTaker" in TidBITS-677) and I opted to take a look at NoteBook. The decision was essentially random at the time, but since then I've become familiar with, and fond of, NoteBook, and the few times I've taken a peek at NoteTaker, I've remained happy with my choice of NoteBook.
Reams of Ruled Paper -- NoteBook is, like so many of these programs, designed to make it easy to store, categorize, and retrieve information. It's built, as you'd expect, on the notebook metaphor, with pages grouped into sections indicated by a tab (which you can Control-click to jump to any page in that section). You can add another layer of hierarchy by creating multiple files, of course, but I prefer keeping everything in a single NoteBook file for simplicity's sake. Individual pages and entire notebooks can be encrypted for privacy.
Information on pages is organized into cells, which can contain text, graphics, audio, video, URLs, files, or aliases to files. You can organize cells in standard outline fashion, with multiple levels of hierarchy. Cells can have dates (creation, changed, due) associated with them, along with action item checkboxes that, when checked, can cause the cell to become greyed out. You can also assign styles to different outline levels, style text independently within any given cell, and set cells to be numbered. For additional metadata, you can assign keywords and stickers (think of them as little graphical keywords) to cells, and you can mark them with a highlighter tool.
I can't say whether NoteBook would meet Matt's standards for outlining controls; it seems to do almost everything I want, and I don't do enough with outlines to care all that much. My only irritation, and I'll explain why I do this later, is that you can drag a cell around to move it, but you cannot drag multiple cells at once; for that you must use cut and paste.
You can add data to a NoteBook page in a wide variety of ways. There's nothing wrong with just typing, of course, but you can also paste in text or graphics, and you can drag data in from other programs. To create a page that collects bits of related text, the easiest thing to do is to assign a "clipping service" to a page; from then on, you can select text in any Mac OS X application (not Classic, of course), Control-click the selection, and choose the desired NoteBook page destination for your clipped text. NoteBook also has a Media Capture capability for importing multimedia files directly from cameras or other devices, along with a Voice Annotation feature for adding voice notes; I haven't particularly used either of these features.
To find information you've stored in NoteBook later, various options are available. NoteBook maintains a number of indices automatically, so it's easy to see entries by Text, Capitalized Words, Numbers, Internet Addresses, Highlighting, Keywords, Stickers, Attachments, Discarded Attachments, Creation Dates, Change Dates, or Super-Find Results. Each of these indices (really a concordance) is a separate page showing lists of cells that match the built-in searches. So the Capitalized Words index, for instance, appears as a big list of capitalized words, organized alphabetically; clicking any word expands its outline level to reveal the actual cells containing the clicked word, and clicking the bullet next to one of those cells takes you to the page containing that cell. You can of course perform normal searches as well, limiting the scope to the selection, to a page, or to the entire notebook.
Despite all that searching power, I seldom use it because I've organized my pages into tabs, and each tab page is a table of contents for the pages inside the tab. Most of the time, I know exactly where the information I want is, so I just go straight there without worrying about a search.
As far as getting information out, you can export in a variety of formats and print; I've used these features only occasionally, since my goal is to keep information in NoteBook, not to use it as a staging area for creating other types of documents.
My Usage -- That's how NoteBook works. I haven't examined large numbers of other snippet-keeping programs to know exactly how they compare, but I will say that those I have looked at haven't floated my boat. NoteBook does what's necessary for my purposes, and it does it in an easy and elegant way. So what are my uses? Perhaps you'll get a sense of what NoteBook could do for you if I describe what it does for me.
To Do List: The reason I keep NoteBook running all the time is that I've taken to keeping my to do list in it. You may have noticed that I didn't talk about any automatic moving of unchecked items or pop-up reminders or anything like that. Those approaches don't work for me - I always end up ignoring them. Now Up-to-Date has a fine to do list capability, moving unfinished items along each day and reminding me nicely that they're not done. But I've learned to ignore it entirely - it does too much for me. In NoteBook, I've created a tab for To Do List, and inside that, I create a page for each week. On each week's page, I have top-level outline entries for the day of the week, and second level entries for each individual item. Most have action item checkboxes, though some items are just reminders to myself about appointments, and those don't get checkboxes. Sometimes a second-level item will end up with notes underneath it (such as when I have a product briefing call with an industry company). Each day I manually move all the unfinished items to the next day (hence my earlier irritation with being unable to drag multiple cells), and each week I create a new page and bring forward everything that's undone. By forcing myself to manage the to do list manually, I never find myself ignoring it for weeks or months, as has happened with every other approach I've tried.
Process Minder: As I've started to move to Web Crossing for our primary server, and as we've built up numerous processes for Take Control, keeping track of exactly how I perform certain tasks has become onerous. I just can't remember how I deal with certain tasks that I perform relatively infrequently, and I also want a record of what I'm doing in case I need to train someone else to do the same tasks. A number of my pages are thus just sets of steps and notes to myself about how I perform a given action. They're invaluable at this point - I would make far more mistakes and forget parts of processes entirely without them.
Internet Research Snippet Keeper: Every now and then I need to research something where I want to collect text from a number of Web sites and email messages, and I use clipping services in NoteBook to facilitate that.
Post-it Note Eliminator: Like many people, I write things down on little bits of paper all the time (not Post-it notes, actually, but old pages from daily calendars, which I love for that purpose). They're great for highly temporary information, but those that contain more permanent notes tend to collect and breed on my desk, so every now and then I go through them and transcribe everything into NoteBook, where I can rest assured that the information won't be lost, and where I can ignore it happily without cluttering my desk.
Project Notes: Sometimes, when I'm working on an article or a talk, I'll need a place to store some notes before I start writing or work up a presentation in Keynote. I've used NoteBook to store those notes in the past, but I've never been wildly happy about it since it feels odd to enter information into NoteBook that I know is temporary; once I write the article or prepare the presentation, the NoteBook pages are utterly useless. I could delete them, but that seems wrong too, somehow.
Minor Quirks -- I've been using NoteBook for quite some time now, and most of the annoyances I've had with registration numbers, crashes, moving files between Macs, and so on have been resolved by small updates along the way. My remaining problems are small. NoteBook doesn't remember its window position on my second monitor, and it won't let me move a window into the area that, if it were on my main monitor, would be occupied by the menu bar. Then there's the inability to drag more than one outline item at a time. You can link a text in a cell to another page in NoteBook, which is handy (I use it in my process pages when a process can be broken down into independent chunks), but you can't link from a cell to another cell.
These niggles aside, NoteBook has proven itself a worthy tool. Until I came up with my to do list approach, I couldn't see how I'd use NoteBook sufficiently to keep it in the front of my brain, but since I started forcing myself to maintain my to do list manually, I've found additional uses for the program, and I've also found myself appreciating what it does for me. There's no question that other programs can perform roughly the same tasks; Matt has reviewed oodles of them in TidBITS. But given a choice of any of them, I'll stick with NoteBook.
NoteBook 1.2 costs $50; a free 30-day demo is available as a 7.7 MB download so you can see if it meets your needs. It requires Mac OS X 10.1 or later.
Article 14 of 21 in series
by Matt Neuburg
After a long beta period (and a name change), TAO 1.0 has finally been released. In the immortal words of Calvin (from "Calvin and Hobbes"): "This is so exciting I have to go to the bathroom!" TAO is an outliner - a writing space for working with items of styled text arranged hierarchicallyShow full article
After a long beta period (and a name change), TAO 1.0 has finally been released. In the immortal words of Calvin (from "Calvin and Hobbes"): "This is so exciting I have to go to the bathroom!"
TAO is an outliner - a writing space for working with items of styled text arranged hierarchically. Even more important, it's an outliner that understands what an outliner is supposed to be. It's the closest any Mac OS X-native program has come to replacing MORE, the dean of outliners and my favorite (even though it was creaky when I reviewed it in TidBITS-198 and is even creakier under Classic).
TAO has a complete repertory of commands for rearranging items. You can create a new item as a sibling (before or below), child, or aunt of the current item. You can select single or multiple items. Items can be joined or split. Items can be moved by dragging or by keyboard shortcut. An item can be hoisted for isolated viewing. An item's children can be promoted; its siblings can be demoted. An item can be cloned (changing one clone changes them all). An item can be collapsed or expanded, locked, and even made invisible. A multi-line item can be reduced to only its first line.
Items can have many attached features. An item can have a label (color), a checkbox, a bookmark, an automatic number, and links to other items. Text can be linked to a URL. An item can include a note (essentially an embedded TextEdit document), a picture, or a link to a file on disk.
Formatting and other features can be applied through stylesheets (collections of rules). You can edit in a split window. You can find by text, label, date created or modified, visibility, bookmark, locked state, or checked state, in one or multiple files. Documents can be exported as plain text, styled text, HTML, and XML (OPML).
TAO is brilliant; it's an amazing achievement. The only thing missing - and unfortunately, it's a big thing - is a proper set of shortcuts for navigating between items. There needs to be a way to navigate directly from an item to its siblings, even if visible children intervene, or to its parent. Once such shortcuts are in place, TAO will be a useful outliner in the true spirit of MORE.
TAO requires Mac OS X 10.2.8 or later, and is $30 shareware. It's a 4 MB download. An unregistered version quits after half an hour, but the download currently includes a trial license valid until 01-Nov-04.
Article 15 of 21 in series
by Matt Neuburg
The world is not a tidy place. That's why I'm constantly discovering new and interesting ways to store and retrieve information on my computer. Typically, those ways involve imposing order through hierarchical arrangement, or retrieval through sophisticated searching: I'm drawn to outlines, databases, keywords, indexesShow full article
The world is not a tidy place. That's why I'm constantly discovering new and interesting ways to store and retrieve information on my computer. Typically, those ways involve imposing order through hierarchical arrangement, or retrieval through sophisticated searching: I'm drawn to outlines, databases, keywords, indexes. This approach, however, doesn't work for everything or for everybody. The mind, after all, is not a tidy place either. Perhaps there is no hierarchy to impose, no keywords to assign, nothing clear to search for. Perhaps you just need to make it up as you go along. Perhaps all you have, and all you need, is a vague mental picture of what you've got and how it goes together. Perhaps there is just the cloudy soup of stuff in your mind (ideas and purposes) and stuff on your computer (documents and URLs).
Curio, from Zengobi, wants to help you slice through the soup, not with left-brained devices such as outlines, databases, and keywords, but with a more right-brained device - pictures. The program describes itself as an "idea development environment," but it could lend itself to all sorts of uses. I'll quickly describe the interface, and then proceed to an assessment of Curio's peculiar strengths.
Cover Your Assets -- A Curio document consists of one or more pages, called "idea spaces." An idea space is rather like a simple drawing document; you might think of it as a whiteboard, or perhaps as a surface you're going to stick Colorforms onto. The objects you can stick onto this surface are called "figures." A figure can be a line (possibly with an arrow), a geometric shape, or a block of text; actually, the latter two are the same, since text can appear inside a geometric shape. Figures can be resized and rotated; multiple figures can be aligned and grouped. A figure can have a checkbox; it can be marked with a "flag" (a little icon such as a question mark); it can be assigned a "rating" (a number of stars from zero to five). You can also scribble on top of everything.
A figure can also represent an "asset." This is where things start to get interesting. An asset is a document on your hard disk; double-click the figure in Curio, and the document opens in whatever application owns it. Or, an asset can be a URL; double-click it in Curio, and it opens in your Web browser. If an asset is something with a ready preview, like an image file, that preview appears as its Curio representation; otherwise, you might just see a document icon and a title. In fact, if you drag an image from your browser into a Curio document, the image is shown as a preview and you can double-click it to go to the Web page it came from.
A Curio document is thus not just a bunch of drawings; it's a bunch of drawings whose objects can refer to the outside world. Indeed, they can refer to the inside world instead: a Curio document is a package, and an asset can be copied to live inside it, where it remains viewable and editable by the program that created it. What's more, a single asset can be represented by as many figures as you like; in other words, a document on your hard disk can appear in several places at once within a Curio document.
So now you see how Curio can bring creative clarity to chaos. Given fifty documents on your hard disk, a single Curio document can make them available in various combinations within multiple idea spaces, accompanied by text, pictures, URLs, and scribbles.
Analysis and Synthesis -- Curio proudly boasts a second-place finish in O'Reilly's 2004 Mac OS X Innovators contest. Yet, if one takes a deliberately critical view and scrutinizes Curio closely, one may start to wonder what the fuss is all about. After all, lots of snippet keepers and organizers that I've reviewed can store links to files on disk (iData 2, Tinderbox, and TAO, for instance), and several can optionally store files inside their own documents (NoteTaker and DEVONthink). Furthermore, looking at any other individual aspect of Curio, it's hard to avoid concluding that the implementation is relatively half-baked: Curio doesn't do any one thing as well as some other program does it. Had the O'Reilly folks, one wonders, ever seen a full-fledged outliner, mind-mapper, diagrammer, or asset manager?
For example, idea spaces in Curio can be arranged hierarchically; and within an idea space, figures can be combined within special figures called "lists" that display a hierarchical arrangement. But Curio can in no sense be used as a real outliner; it lacks anything like the hierarchic organizational and navigational power of a TAO or a NoteTaker.
Curio's drawing abilities are cute, but you couldn't use them to do any serious drawing. It's nice to be able to draw shapes and arrows, but the arrow endpoints don't magically stay attached to the shapes, so you can't create true diagrams as in ConceptDraw or OmniGraffle, nor can you generate and connect ideas efficiently as in a dedicated mind-mapping program like Pyramid or even Inspiration.
Curio has a search feature, but it simply searches on text blocks you've created and notes you've attached to assets; it can't search inside the content of the assets - it can't even search on whether or not something is checked or has a certain flag. And its idea of displaying what you've found is not to collect the results, but simply to dim what wasn't found - you still have to go scrolling by eye through all your idea spaces looking for the found figures. Contrast this with the powerful keywording and indexing of Tinderbox or DEVONthink, or the searching of NoteTaker or TAO.
A figure can be a "jump target," meaning that double-clicking an arrow image in one idea space reveals that figure in a different idea space. But this doesn't work between Curio documents, and is a far cry from true hyperlinks as in Tinderbox or NoteTaker.
Curio provides a Web-searching tool called "Sleuth," but it's merely a preconfigured front end to existing search engines and other sites. It doesn't search more than one engine at once or provide a compact interface, like Sherlock, nor does it collect your results for you, like DEVONagent. In fact, it really isn't a search tool at all; it's just a Web browser, offering no tangible advantage over using a real Web browser. Plus, there are no Services for instantly plopping a document or a Web page into Curio without leaving the Finder or your browser; contrast NoteTaker and DEVONthink.
If, on the other hand, you keep your attention on the notion of Curio managing and presenting your assets, some of these reservations may fall away. Curio, after all, doesn't need to be a super drawing tool, because if you want to include a super drawing in your Curio document, you can - and you can edit it with some super drawing application. It doesn't need to be a great word processor or a great outliner, either, because you can embed a word processing or outlining document from some other application inside a Curio document. In fact, you can create a new document of any kind from within a Curio document: hand Curio an empty document once, and you can then duplicate that as an embedded asset and represent it in an idea space, ready for editing, in a single move.
To appreciate Curio's strengths, therefore, concentrate on assets that you have, or you are thinking of collecting or creating - pictures, URLs, PDFs, spreadsheets, Word files, documents of any kind. Imagine presenting those assets arranged on whiteboards, and imagine those whiteboards clumped together in a single document. You might present them to yourself as a way of simply organizing them; you might use Curio for its intended purpose of "idea development," collecting and presenting the assets as part of some research or brainstorming project. You can also present them to others; Curio has amazingly good HTML export (with assets accessible through file protocol URLs), and you can export the whiteboard appearance of your idea spaces as PDFs or image files.
Conclusions -- If you can imagine slicing through the soup of chaos - the chaos of your hard disk or the chaos of your mind - with a few bright, simple drawings, then Curio beckons like a lighthouse in the darkness. The program costs $130, which seems a bit high given the inchoate nature of its feature set (I was honestly expecting something more in the realm of $30), but potential users can decide for themselves, because a 30-day demo is available as a 5.6 MB download. Curio comes with decent online help, and is accompanied by a tutorial which, while useful, sometimes reads startlingly like one of AltaVista's Babel Fish translations ("Get on the good foot with Dossiers!"). It requires Mac OS X 10.2.8 or above.
PayBITS: Want to reward Matt for helping to clear
away your computer clouds? Send him a few bucks!
Read more about PayBITS: <http://www.tidbits.com/paybits/>
Article 16 of 21 in series
A few weeks back, Circus Ponies released version 2.0 of their elegant note-taking and snippet-keeping application NoteBook, significantly improving the program in key areasShow full article
A few weeks back, Circus Ponies released version 2.0 of their elegant note-taking and snippet-keeping application NoteBook, significantly improving the program in key areas. The upgrade reportedly adds over 150 features and is available for free to existing owners, although you do have to upgrade your license code to mesh with a new licensing system.
As I wrote in "The Well-Worn NoteBook" back in TidBITS-745, I've become a devoted user of NoteBook for to-do lists, recording steps in complex processes, keeping snippets of information from email or the Web for research, and for eliminating all those little pieces of paper that breed in the dark recesses of my desk. My basic uses for NoteBook haven't changed, nor has its basic approach, so reading my previous article will give you a more full impression of the program.
Contents Card -- With NoteBook 2.0, some of my uses have become more fluid thanks to new features. Most notable is a new Contents Card, which is a thin drawer-like element that provides an always-visible view of the table of contents of your notebook file. That may seem like a small change, but in fact it's tremendously helpful because it lets you keep an outline of your notebook's contents in sight while you're working. Plus, you can move items between pages by dragging to the appropriate spot on the Contents Card. I find myself using the Contents Card constantly. The main improvement I'd still like to see with regard to seeing more content simultaneously is the capability to show two independent pages at the same time; something that fits in nicely with the physical notebook metaphor.
To Do Items Index -- Since I last wrote about NoteBook, I've changed my style of handling to-do items, thanks in large part to reading David Allen's "Getting Things Done" book. Before, I was tracking to-do items with a page for each week, and an outline heading for each day. Although that worked fairly well, I was starting to learn how to ignore items in the list, so each day was filling up with items I stood no chance of doing. In the Getting Things Done model, the goal is to come up with the next action in any given project, and to categorize them not by project, but by context: calls, email, writing, errands, and so on. The idea is that then, when you sit down to do work, you can look at what's on the list for that context and pick out something to do that makes sense with the time and energy available. Obviously, the overall approach is more complicated than that, but it's working well for both Tonya and me, and I've changed how I handle to-do lists in NoteBook accordingly.
Now I have a section of my Notebook file with a page for each context I'm trying to track, and a set of action items on that page. I also have agenda pages for each of the people I work with regularly so I don't forget things that need discussing. Nothing in that wasn't possible in previous versions of NoteBook, but since the NoteBook folks have also been reading "Getting Things Done," there are some new features that help out with such organization. Most notable is a To Do Items Index, an automatically generated page that collects all your action items (lines to which you've assigned a checkbox) and shows them in two sets: incomplete and completed. It's a great overview of all the action items spread across all my contexts; something the Getting Things Done model would suggest you should review every Friday to make sure you're not falling behind on some project.
Sorting, Linking, and More -- Another area where NoteBook 2.0 has improved is in sorting; you can now create sorts and have them applied automatically. I've had some trouble getting this feature to work as I'd like; auto-sorting seems a bit finicky at the moment, but when it works, it's a great way to organize action items on a page by whether or not they're completed and when they were last modified.
I've also taken to doing a bit more linking, now that NoteBook 2.0 can create links not just between pages, but between cells. For people who use multiple NoteBook files, you can even link to cells in other files.
Clippings now include a lot more metadata related to the clipping source, so you can easily determine the application from which the clip originally came, and if it came from Apple Mail, the item is automatically linked to the sender's Address Book entry, if present.
There are a slew of other features that I haven't yet had an excuse to use. Integration with Apple's bundled applications (none of which I use, unfortunately for this context) has improved greatly, so you can easily link to contacts in Address Book and initiate iChat sessions or email messages in Mail directly from NoteBook. NoteBook can also generate alarms in iCal for action items that have due dates; it's a nice way to gain alarm capability without writing yet another reminder system. For those who like toolbars, there's now a completely customizable toolbar that can appear at the bottom of your NoteBook window; the main thing I like about it is the breadcrumb display of your current location. The Voice Annotation feature now enables you to record lengthy sessions, adding notes at relevant points. You can send voice annotations to iTunes for listening or for downloading to an iPod. And speaking of iPods, you can even send a NoteBook outline to your iPod for viewing using the normal iPod interface. HTML export has improved, making it easy to create full NoteBook-generated Web sites, complete with internal navigation.
With some pieces of software, I immediately think of features to request, and apart from the double-page view, that's not happening with NoteBook. In fact, it's the reverse. I'm always a little depressed when I see, in the process of writing about a piece of software, how much of it I haven't yet delved into, especially in a program I use daily like NoteBook. But on the bright side, it also means that there's always more to learn. The hard part is remembering that the features exist when a need arises. Perhaps I'll have to devote a page in NoteBook to features in programs that I don't need now, but which might be useful in the future.
NoteBook 2.0 costs $50 for new customers; upgrades for existing customers are free. Educational and volume discounts are available, as is a free 30-day demo version. The program requires Mac OS X 10.3 or later.
Article 17 of 21 in series
by Matt Neuburg
DEVONthink is a snippet keeper, where a snippet can be anything from a few words of text to a Web page, a Word document, a PDF, or any of several other formatsShow full article
DEVONthink is a snippet keeper, where a snippet can be anything from a few words of text to a Web page, a Word document, a PDF, or any of several other formats. Within DEVONthink's database, documents can be organized hierarchically and mutually referenced via hyperlinks. DEVONthink can link to any file on disk, but its real power emerges when the file is something it can parse and index, giving play to its mighty powers of searching, cataloging, and cross-referencing.
When I reviewed DEVONthink in TidBITS-720, I praised its interface and its searching capabilities, but I pointed to one shortcoming in its architecture: there could be only one database. This, I suspected, would ultimately prevent me from using the program at all; and I was right. Now, however, that restriction is lifted, thanks to the long-awaited release of DEVONthink Professional 1.0.
In DEVONthink Professional, a database functions as a kind of document. Only one database can be open at a time, but I don't regard this as an impediment. With separate databases for different collections of data, I'm at last able to use DEVONthink seriously.
The other major innovation in DEVONthink Professional is its AppleScript support. Earlier versions were a little bit scriptable, but DEVONthink Professional takes scriptability much further - and wears its scriptability on its sleeve. The program has a Scripts menu and comes with many example scripts that users can take advantage of immediately to make DEVONthink cooperate with other applications - fetching all links from the current Safari Web page, for example, or importing selected email messages. What's more, a script can be attached to a file or a folder within the database, so the script is triggered when the item is opened; in the case of a folder, for instance, this capability enables the creation of a "smart folder" that populates itself automatically when opened. DEVONthink also comes with some Automator actions, along with example Automator workflows.
Another new feature is the capability to download Web pages linked from a given page. That's a terrific idea, and I was eager to try it, but I found it nearly impossible to tweak the settings so as to obtain the desired results. (DEVONthink's developers could usefully study the SiteSucker utility.)
Also new is that you can make a page that's like a simple database table, where each column is a field and each row is a record; such pages (unaccountably termed "sheets") can't have styled text, though, which limits their usefulness.
Finally, it's worth noting one feature conspicuous for its absence: complex boolean searches are still not implemented, even after years of complaints from users and promises from the developers.
DEVONthink Professional is a big step closer to what DEVONthink should have been all along. Whether that warrants the "Professional" label or the price tag ($75), market forces will show. Meanwhile, you should definitely try this program for yourself; the demo download expires after 150 hours of use and is not limited in any other way. Mac OS X 10.3.9 Panther is the minimum operating system version required, but given the number of new technologies it uses, to run DEVONthink on anything less than Tiger would be a pity.
Article 18 of 21 in series
by Matt Neuburg
The latest entry in the ever-growing roster of information organizers comes from Bare Bones Software, maker of such programs as Mailsmith and BBEdit (and its freeware little brother, TextWrangler)Show full article
The latest entry in the ever-growing roster of information organizers comes from Bare Bones Software, maker of such programs as Mailsmith and BBEdit (and its freeware little brother, TextWrangler). Yojimbo, whose evocative name means roughly "bodyguard for hire" in Japanese (as in the classic Kurosawa film), is distinguished by its ease of use and the way it supplies structure to certain types of data.
Yojimbo's approach to maintaining information is simple. You have a single database of items, called the Library. An item can be text (possibly styled, and possibly including images), a URL (called a "bookmark"), an archive (either a Web Archive of the sort that Safari now knows how to save, or a PDF), a serial number, or a password. (Arbitrary files, such as images or Excel documents, or aliases to such files, cannot be stored as items in Yojimbo.) A particularly nice touch is that you can create a PDF and save it into Yojimbo in a single move, using the Save PDF in Yojimbo command in the PDF pop-up menu of any application's Print dialog. (You might use this feature, for instance, to store copies of receipt pages from Web orders.) Any item can be encrypted, and to enable this, you must assign the library itself a password; password items are always encrypted. A preference lets you decide whether you want to be prompted for your password every time you decrypt an item to read it.
You don't have to work directly in Yojimbo's window to throw items into it. A system-wide hotkey summons the Quick Input Panel, in which the current clipboard contents are turned into an item and where you have an opportunity to determine what kind of item it is and assign a title. There is also a drawer at the edge of the screen (the Drop Dock), into which you can drop items. Finally, you can drop text and PDF files (one at a time, or in batches) on Yojimbo's Dock icon to import them. Unfortunately, there's no way to import a tab-delimited text file of passwords or serial numbers into individual password and serial number items, making it difficult to migrate existing collections of data from other applications into Yojimbo. And Yojimbo isn't scriptable with AppleScript, so the best way to transfer such existing data to Yojimbo may be organically, as you use the information.
In keeping with its goal of direct simplicity, Yojimbo supplies only a modicum of organization. You can flag an item, or assign it a label (a color). You can create "collections" (like iTunes playlists or iPhoto albums) and assign an item to one or more of them. There are also some built-in "smart collections" which present categories of items, such as all text items or all flagged items. And a search field lets you find items based on their titles, contents, or comments, instantly. (But you cannot nest collections, create your own smart collections, or save a search.)
In situations where it makes sense (bookmarks, serial numbers, and passwords), Yojimbo provides a set of fields to hold the different pieces of data in the item. So, for example, a bookmark has a name field, a location field, and a comments field; a serial number has a name, the serial number, and four further fields. This is a good use of structure where it makes sense, without imposing it on the text and archive item types that don't need it. However, you can't define your own fields for custom types of information. If this became possible in a future version, you could use Yojimbo to store (for example) recipe references, with fields for name, cookbook name, page number, and so on. I currently use iData 2 as a lightweight flat-file database for this sort of thing, but surely the point of an information organizer should be that you can keep any kind of information in it. As so often, I'm reminded with nostalgia of the wonderful WebArranger, which permitted you to define your own item types, each with its own set of fields.
You would expect from the thoughtful and accomplished folks at Bare Bones a certain clarity and slickness of interface, as well as a showpiece that takes advantage of the brightest and best among system technologies. With Yojimbo, that's just what you get. Yojimbo is a Tiger-only application because it relies on the latest Mac OS X advances. For instance, it's a Core Data application, so that your items are kept easily and automatically in a SQLite database. Yojimbo also makes all non-encrypted items individually available to system-wide Spotlight searches, by representing each one as a stub in your Caches folder. (Whether you regard this as a felicitous choice depends upon your point of view. I don't want more matches in my Spotlight searches; I want fewer!) And if you have a .Mac account, Yojimbo can use the .Mac SDK to synchronize your Yojimbo data between machines, so you can retrieve your passwords and serial numbers while using your iBook on the road.
Bare Bones's Yojimbo Web page asserts that the program has "no learning curve"; and this, allowing for the usual pedantic disagreements over what the phrase "learning curve" means, is absolutely true. Download it and run it; in less than a minute, you will know exactly how to put data into it and find what you've put in. Much as I appreciate the effort that Bare Bones has put into Yojimbo, though, it's not a particularly ambitious application and may not compel people to switch to it from other programs that offer roughly similar features. Nevertheless, anyone who has hesitated to try any information organizer because they all seem overly complex and confusing might well be attracted to Yojimbo's direct simplicity and should certainly give it a try.
Yojimbo requires Mac OS X 10.4.3 or later; it costs $40 for an individual license that may be used by one user on multiple machines, $70 for up to five users with multiple machines, or $30 for educational users with a single machine. The demo version expires after 30 days.
Article 19 of 21 in series
by Matt Neuburg
Back when I was writing my doctoral dissertation (and we lived in holes in the ground and had to clean the roads with our tongues on the way to school), I had a big box full of large index cards, on each of which were the notes from one book or article I'd readShow full article
Back when I was writing my doctoral dissertation (and we lived in holes in the ground and had to clean the roads with our tongues on the way to school), I had a big box full of large index cards, on each of which were the notes from one book or article I'd read. These were no ordinary index cards. They were high-tech! To help me navigate the complex of their mutual associations, the cards had little holes all around the edges. On each card, using a special hand punch, I would clip a notch from the edge of the card to a hole or holes corresponding to a "keyword" or idea dealt with in that book or article. To "search" the box for cards associated with a certain keyword, I slipped a knitting needle into that hole, and lifted and shook the cards. All cards that fell off the needle onto the desk (or floor) had that keyword. To do an AND search or an OR search, I just repeated the action with the fallen cards or the cards on the needle, respectively. I was the envy - or was it the laughing-stock? - of Cornell University's Olin Library.
Oh, how I wish I'd had Markus Guhe's SlipBox. (And a personal computer. And electricity.)
It was probably inevitable that I'd be attracted to an application like SlipBox. In the first place, it's a snippet keeper, a classification that always interests me and about which I've written extensively in TidBITS. Second, just like my own applications, it's a simple tool that the developer originally created for his own use and to meet his own needs, and then proceeded to give away for free.
SlipBox has two distinguishing features: simplicity and "scents." Let's start with the simplicity. A SlipBox document is, metaphorically, a box of index cards ("slips"). On each card you can put whatever you want. There's one big field for styled text, which can include pictures and even entire files (or links to files). There are also three non-styled fields for adding keywords, source, and type information. You can add a card, navigate between cards in order, and navigate "forward and back" among recently viewed cards as in a browser. There's also a Search tab, in which you can search on the keyword field, the source field, or the full text; a nice touch is that you can preview a found card's text right in the Search tab, or you can click a checkbox to "mark" it for later viewing in a separate read-only window. And that's about it. So far, SlipBox sounds rather like iData 2 - a flat-file free-form database, a digital shoebox (see "iData Pro, Go Cocoa," 09-Aug-04).
Now, however, we come to the "scents." Scents are SlipBox's distinguishing feature, and here's how they work. When you create and populate a card, you are expected to give it some keywords. These keywords need to have some consistency from card to card (if you use the keyword "Socrates" on one card you probably wouldn't want to spell it "Sokrates" on another). To help you with this, a drawer displays all existing keywords in alphabetical order; double-click one to add it to the list of this card's keywords. Or, just start typing in the keywords field, and the likeliest matching keyword will be auto-completed for you. In supplying these keywords, you are expected to free-associate, but, as SlipBox's online help charmingly advises, you should not "try to create an ontology of keywords" - that is SlipBox's job.
So what is an "ontology of keywords," and what's a scent? It's simple: a scent is the (possibly forking) path created by associations of keywords on the same card. The ontology is the complete collection of such paths.
For example, suppose one card has the keywords "line" and "bug" and another card has the keywords "formatting" and "bug". Then the following scents are created:
bug formatting line formatting bug line line bug formatting
That's a ridiculously simple example, of course, but it serves to show the idea. Just keep extrapolating. (There will be a scent leading from keyword A to keyword B if A and B appear on the same card, or if they each appear on different cards along with keyword C, or if A and C appear on one card, B and D appear on another, and both C and D appear on cards along with keyword E - and so on.) The idea is that you can use scents to trace associations at a distant remove, of which you would not otherwise have been aware.
The scents themselves appear in outline form in the Keyword Scent tab of your document. So, the top level of this outline is exactly the same as what appears in the keywords drawer - it's an alphabetical list of all keywords. But this is an outline, so you can click the triangle next to a keyword to see the keyword(s) associated with it (as in my diagram, above). If you double-click a keyword, you're taken to the Search tab and the search is performed, so now you're looking at a list of all cards containing that keyword.
What's really so delightfully compelling about this whole system is that it's stupid. SlipBox isn't doing any data mining or linguistic analysis, so you're spared the complexities of something like DEVONthink (see "DEVONthink Thinks, So You Don't Have To," 08-Mar-04), which attempts "intelligently" to divine the contents of your snippets and to associate them for you. SlipBox isn't intelligent at all; it's merely presenting, in outline form, the card-and-keyword pairings that you yourself have explicitly constructed by using them on the same card. And that is precisely what I would have needed when I was writing my dissertation. It would have done all that my index cards did, but it would have been even better, because in addition to doing searches, I might have learned something about how the ideas in my dissertation were connected.
SlipBox has a few additional bells and whistles. It can search a BibDesk database, it can use GraphViz to chart your keyword ontology, and you can search your SlipBox documents with Spotlight (though I happen to believe that this feature is incorrectly implemented). You can export to plain text or to RTFD, link from one index card to another, and create an index card from within another application, using Services. SlipBox suffers from one curious limitation: you can't delete a card; I believe this is because of the way each card is assigned a number incrementally at the time of creation. But you can move a card into the Trash, which takes it out of the searchable nexus, and even more important, you can move a card from the Trash back into the normal card world and then just reuse it, emptying its fields and giving it completely new content.
What SlipBox needs now is more users and some intelligent feedback for its developer. So if you're looking for a simple snippet keeper, please give SlipBox a try. SlipBox is a 1.3 MB download and requires Mac OS X 10.4 Tiger. It's a lot better than a box of index cards, a special hole punch, and a knitting needle. And did I mention it's free?
Article 20 of 21 in series
by Matt Neuburg
A mind map is a diagram of connected ideas. In the past, I've written about various mind-mappers, including the minimalist Pyramid ("Pyramid Therapy," 2004-09-13) and the full-featured NovaMind ("Draw What's On Your Mind With NovaMind," 2006-04-17)Show full article
A mind map is a diagram of connected ideas. In the past, I've written about various mind-mappers, including the minimalist Pyramid ("Pyramid Therapy," 2004-09-13) and the full-featured NovaMind ("Draw What's On Your Mind With NovaMind," 2006-04-17). Recently, a new heavy hitter has appeared on the scene: Mindjet MindManager 6. The "6," a surprisingly high version number for an initial release, is because MindManager has actually been around for a long time over on That Other Platform. The Mac version is in no discernible sense a port, however; it's a true Cocoa application from the ground up (indeed, the story of its cross-platform migration was recently featured in a puff piece on Apple's own developer site).
The Good -- MindManager is very easy to start using. As you brainstorm, press Return to add a topic at the current level, or Command-Return to add a child of the current topic; that's basically all there is to it. Yet at the same time, MindManager is extremely full-featured. A topic can also have callout topics (ancillary attached information), and you can make floating topics (unattached to anything). An image can be added to a topic, from a file or from MindManager's own library. A topic can have markers, which are little decorative icons, such as smileys or colored flags, or text boxes indicating things such as whom a task is assigned to. A topic can have a note, which is styled text. It can have a date, and can be assigned a priority.
A topic can be hyperlinked to another topic, to an http or mailto URL, or to a file or folder on disk. A topic can also be given file attachments; these are files of any kind, which actually live inside the MindManager document and open on command. A boundary, optionally labelled, can be drawn around a topic and its subtopics. A relationship, which is basically a line or curve (also optionally labelled) can be drawn between topics, and you can jump from one end of the relationship to the other. The entire visual presentation of the document is very competent; topic selection and navigation works just as you'd expect.
The Bad -- Considering its maturity, I found much of MindManager's implementation to be surprisingly rough, flawed, or downright lacking. For example, the physical positioning of topics drove me crazy: the program insists on auto-positioning everything for you, with the result that sometimes I would drag a topic to the left and it would jump further right than before. Topic markers come in groups, and when you click one it changes to a different marker in the same group without asking or warning you. There are two ways of hiding topics temporarily: you can collapse a topic's subtopics, or you can choose from the Filter menu to hide selected topics; that's great, but in the latter case there's no visual indication whatever that hidden topics exist. A topic can be "bookmarked," but bookmarks have no names so this feature is sort of useless (all you can do is jump from one bookmarked topic to the next). A document can be exported as a graphic or as text, but not in any complete and universal format such as XML. Contextual menus often lack important commands applicable to the selection.
Most frustrating of all, I found MindManager to be barely competent as a drawing program. The thickness and style of a topic's geometrical shape can't be changed, and I had great difficulty setting the shape's fill color: sometimes I could get it to work, sometimes not, and I never figured out why. Maintaining stylistic consistency among topics is possible, though perhaps a bit challenging. (The documentation says, "If you are an experienced MindManager user you can create your own styles," which sounds more threatening than helpful.) Named styles don't exist. You can copy and paste styling, but you get no choice of what stylistic aspects to copy and paste: it's all or nothing. You can select a topic or other entity and dictate that its styling should be used as the default. And MindManager uses a complicated system of templating where a document or part of a document can be saved into a library and used as a stylistic basis for future documents. It's all rather confusing, really.
Finally, the documentation is a lot of disconnected Help Viewer pages, many consisting of vapid chatter such as how to close a document by clicking on the red button in the title bar; thus, working your way through the help is a difficult, time-consuming, frustrating, and mind-numbingly dull task.
The Ugly -- Overall, MindManager is slick and generally easy to use, but I'm forced to conclude that, considering the state it's in and the nature of the competition, at $230 it may be overpriced. Still, it costs nothing except the submission of your email address to download it (50 MB) and give it a try. MindManager requires Mac OS X 10.4 Tiger or greater.
Article 21 of 21 in series
by Matt Neuburg
Got miscellaneous data to search for? You've organized your files into folders and you still can't find the right one? Let EagleFiler add searching, tagging, and annotation. Problem solved.Show full article
In nearly two decades of experimenting with ways of storing and retrieving text and other snippets of information, largely documented in the "Conquer Your Text" series of articles, I've found that most applications take a fairly heavyweight approach, requiring me to hand my data completely over to their care, keeping it in a specific place or (even more often) in a document and format specific to the application. That's why I was intrigued by the lighter touch of EagleFiler, from C-Command (the development house of Michael Tsai, who also writes SpamSieve (see "Tools We Use: SpamSieve," 17 February 2003) and other utilities I wouldn't want to be without).
EagleFiler's chief document type is called a "library." You can have as many libraries as you like, and each library is just an ordinary folder in the Finder, containing files that are your data; each snippet is simply a file in a standard data format. A library also contains some housekeeping files maintained by EagleFiler. So you do have to make a conscious decision to keep particular snippets in a particular folder - the snippets can't be scattered all over your hard disk - and you do need, in general, to refrain from altering the contents of that folder directly, interacting with them through EagleFiler instead. But all the same, there are your snippets just sitting there, ordinary files in an ordinary folder, completely visible and accessible in the Finder. You can search your snippets within EagleFiler, but you can also search them with system-level Spotlight. You can open them directly in the Finder. If the world were suddenly struck by mysterious cosmic rays that destroyed EagleFiler, none of your data would be lost, because your data are just normal files in folders.
In the distant past, one might have criticized this scheme for wasting space. Even a tiny text file occupies a minimum logical space on your hard disk - typically 8 KB. So, while 100 snippets of 10 bytes of text data apiece sum to about a kilobyte, 100 files of 10 bytes apiece require nearly a megabyte. However, in the modern scheme of things, where a hard disk will typically have dozens of gigabytes of free space, a few extra megabytes are hardly problematic.
Window on the World -- Since EagleFiler's data are just files in a folder, its chief value lies in its presentation of those files, and how it lets you annotate and search them. I'll start by describing the library window. The basic layout is reminiscent of Mail's tripartite window. At the top is a list of files in the library (called "records"). At the bottom are the contents of the record currently selected in that list. And on the left is a sidebar where you can select to specify the subset of records you want listed at the top.
The sidebar has three sections. First comes a hierarchical list of folders. Here you can make new folders, put folders within folders, and organize records into folders; these folders are real, reflecting and controlling the actual folder hierarchy within the library folder in the Finder.
The second sidebar section is smart folders. As in Mail or the Finder, a smart folder is a saved set of search criteria; clicking one performs the search, determining which records are listed at the top. You can construct (through an excellent interface) some powerfully complex search criteria.
The third sidebar section is tags. You can create tags at will, and assign any number of them to a record; and tags can be structured hierarchically.
So, the sidebar is itself a search mechanism, because you can select any combination of folders, smart folders, and tags to determine what's listed in the top half of the window. In addition, at the very top of the window (in the toolbar) is a search field. EagleFiler's search really shines; it's based on Spotlight (so it can index any file that Spotlight knows how to index), but it uses its own index (making it super-fast) and its own straightforward Boolean syntax.
There is also a secondary Info (or Inspect) window. Here, among other things, you can read and edit a record's "note." A note is an RTF file, associated with a record, that EagleFiler stores for you in a separate Notes folder within the library folder. Thus, you can attach text to a record in addition to its title and contents. And once again, if EagleFiler weren't present, you could still read all your notes, as they are normal RTF files openable in TextEdit.
A World of Data -- EagleFiler can import any kind of file. Within EagleFiler, you can edit a file's title (which is displayed in the upper part of the window), and, in the case of RTF and text files, even its contents. You can ask EagleFiler to open any record via the Finder, but this is often unnecessary, since EagleFiler can display the contents of many file types, and some file types receive special treatment of other kinds. Perhaps the best way to give you some idea of this is to describe some of my own various EagleFiler libraries.
- Notes. This is a large miscellaneous library of text and RTF files. They are vaguely categorized using tags ("Ruby", "Cocoa") but in no other way; I search on them mostly by title or contents.
- Scans. I got tired of saving all my old paper warranties, instruction booklets, receipts, and so forth, so I scanned them all. These files are just images, so they have no internal data; therefore I've given them titles and notes that are descriptive and flexible, for the sake of searchability. The files are JPEGs, and EagleFiler's display of their contents is usually quite sufficient when I need to examine one.
- Orders. When I buy something over the Web, I save a PDF of the browser's receipt page in this library. (This save can be performed in a single move, using the Save PDF to EagleFiler command that appears in every application's Print dialog.) Tags let me specify the stage the order is at ("ordered", "shipped", "received").
- Mail Archive. I use Entourage, which keeps its mail in one gigantic, all too easily corrupted database. So every once in a while I export an Entourage "folder" that's no longer active to EagleFiler and delete those messages from Entourage. EagleFiler keeps each "folder" as an mbox file, but it displays the messages individually using the subject line as the title, and it knows (and displays) a message's From, To, and Date information. All embedded attachments are maintained. Naturally, messages are searchable by contents.
- Bookmarks. This is a massive hierarchy of URL files.
These have all proven to be splendid uses of EagleFiler, except for my Bookmarks library (which is not working out, for reasons I'll discuss in the next section).
Conclusions -- EagleFiler combines ease of use with an underlying ingenuity that makes it feel simple, fast, and lightweight. It's packed with too many clever touches for me to list. The range of things you can import, of ways you can perform an import, and of smart things EagleFiler can do in response, is quite astounding (and you can use AppleScript to extend its powers even further); read the manual online if you want to know more. To give just one example: Suppose EagleFiler isn't even running; well, every library folder contains a To Import folder, and whatever you place there will be imported into that library automatically the next time EagleFiler opens that library. Brilliant.
At the same time, I've occasionally encountered problems with EagleFiler's interface. In fact, over several weeks in 2009, when I was first giving EagleFiler a serious try, I reported many interface issues. Most were small and were quickly fixed, such as a text field that refused to accept a space character, windows opening at the wrong time, a window that forgot what text field I was working in when I returned to it, that sort of thing. On the other hand, EagleFiler still starts up unbelievably slowly, and its Help menu is still extremely slow to pop down when you click it, apparently due to EagleFiler's being written with the PyObjC framework.
And, while EagleFiler is excellent for storage of an occasional URL file, it can't substitute for a full-fledged bookmark repository. The hierarchical display of folders in the sidebar lacks the organizational power of a true outliner. You can't edit an imported URL, so if a Web address changes, you can't change the corresponding listing within EagleFiler - you have to delete and replace the existing URL file. And, while there are various ways to import a Web URL - as a bookmark file, a text file, a PDF, or a Web archive - there's no interface for picking an option at import time: you have to specify it beforehand in the application's overall preferences. (However, you can use a cool browser bookmarklet to overcome this limitation.)
But I've been very happily using EagleFiler otherwise. I'm probably not using it to its full potential, and yet it has already replaced several other snippet keepers in my arsenal. And it's a whole lot better than using the Finder alone! If you already have a folder full of related things, and you still can't readily find the right one, that folder is a candidate for being turned into an EagleFiler library. In fact, that's how I really think of EagleFiler - it's a Finder folder on steroids.
EagleFiler requires Mac OS X 10.4 or later, with 10.5 or later recommended. It costs $40, and you can download and try it for 30 days for free.