Leading items

The Grumpy Editor's guide to note-taking applications

This article is part of the LWN Grumpy Editor series.

Your editor is not always the most organized person. He is pretty sure he still has a desk under the pile of papers, unpaid bills, and random electronic components that surrounds his monitor - but he has not seen it for some time. There are lots of sheets of paper full of handwritten notes on that desk, but many of them have not seen the light of day for years. There's probably some good stuff to be found in there, somewhere.

This is the information age, of course, and paper full of handwritten notes is tremendously obsolete. Your editor's pen just doesn't have enough fonts, and, besides, contemporary disk drives allow for the creation of much higher piles of stuff. It's clearly time to go electronic.

There are numerous applications out there which are aimed at people trying to create a digital note pile; your editor decided it was time to give a few of them a try. As a way of narrowing the field somewhat, only graphical applications were considered; command-line utilities, Emacs modes, and so on were taken off the list. There's no shortage of web-based wiki systems which can be employed in this role, but they are a topic for another article some other time. Finally, there are a few systems which are aimed at "mind mapping," which is a different objective entirely. Mind mapping applications are on your editor's list to review, but, according to his kids, your editor has lost his mind entirely and will thus have a hard time mapping it.

Each application was looked at from a simple point of view: how well does it support the tasks of quickly and easily creating, organizing, finding, and using notes? There are, as we will see, a few approaches to this task.

xpad

There are a few applications which try to emulate the classic yellow pad of sticky notes - but without the glue; xpad is one of those. It maintains a series of little yellow windows, each of which can contain simple text in a single font. The font and colors can be changed, but only on a global basis. The first line of notes in each window becomes the title for that window.

Like a number of note-taking applications, xpad puts an icon into the panel task area. Simply clicking on that icon appears to do nothing - though double-clicking causes all known notes to show up in the current workspace. The right mouse button yields a menu with the titles of each note window, along with "show all" and "close all" options. "Close all" doesn't just close the windows, it causes the application to exit completely.

There is an "edit lock" feature in xpad; it turns off editing on all notes. There does not appear to be a way to lock a single window. There's not a lot of other features available: no searching, no linking between notes, no audio effects, etc. As a basic notepad, however, xpad seems good enough.

xpostit

Xpostit may be the oldest of the applications reviewed by your editor. It has no web page; it would, in fact, appear to predate the web. It features those round Xaw buttons which became briefly popular after X11R4 came out. Beyond that, the interface is quite strange. Running xpostit pops up a single, small (maybe 1.5cm square on your editor's display) window with a plaid, presumably trademark-infringing design. Clicking on that window does nothing until the right button is used, at which point the user is rewarded with a menu allowing the creation of notes in several predefined sizes.

Note windows contain simple text in the ugliest monospace font the developers could find. There is, beyond doubt, some X resource which can be employed to change that font, but your editor, it must be said, has not found messing around with X resources cool for some years now.

Xpostit is one of the few notes applications with a "save" button; most of them save notes implicitly. There are no features of interest beyond the provision of containers for bare text. There is no panel icon, and no way to find a specific note beyond getting them all on-screen with "show all" and starting to dig. In your editor's opinion, xpostit is an application whose time has passed.

knotes

KNotes is a KDE-based notepad; like others, it is based on the little yellow window concept. It has a more contemporary feel, however, and is notably nicer to work with. The initial impression can be just a bit off-putting, though, at least for those running KNotes outside of a KDE desktop. KNotes puts up a shaped window without the usual window manager decorations; instead, there is a yellow title bar with a red thumbtack in it. The thumbtack does not appear to do anything other than function as a cute example of the X11 shape extension. The title bar can be used to drag the window around in the usual way, but employing the right button does not yield the usual window manager menu; instead, most of the KNotes functionality can be found there.

KNotes puts an icon in the task area; clicking on it gives a menu of note titles. Selecting a title will move to the virtual desktop containing the note (if any), a bit of a disorienting experience for users who are not expecting it. Even worse, it remembers which desktop last contained a note, and will put the note back in that desktop before moving. The right mouse button gives a menu with a number of options, including creating new notes, adjusting the ample (this is KDE, after all) configuration options, and searching.

The search function is a valuable thing for a notes application to have; once the number of notes gets large, it can get hard to remember where something specific can be found. KNotes search is nice, in that it searches through all notes and it supports regular expressions. There are a couple of rough spots, though; if the next occurrence of the desired text is in a window found on a different virtual desktop, it moves the desktop rather than the window. Then it helpfully puts up a little "search for the next occurrence?" dialog - directly on top of the window containing the text the user was looking for.

There are a few features unique to KNotes. One of those is alarms, added presumably so that the user can use notes as a simple appointment manager. There is an option to send notes via email. It is also possible to send notes directly to an instance of KNotes running on another system - though the acceptance of notes over the network is (sensibly) turned off by default. Notes can be locked on a per-note basis, preventing inadvertent modification of notes when desired.

Another nice feature is that notes can be dismissed by hitting the escape key. As a result, pulling up a note, adding a line, and making it go away can be a very quick operation - and that, in turn, encourages the keeping of good and complete notes. Without the desktop warping, KNotes would be almost perfect as a simple, quick, capable, and visually attractive notes manager.

It's worth noting (so to speak) that KNotes is also available as a component of the Kontact organizer. Running Kontact gives access to all of the notes created in KNotes, but it appears that the full integration of this functionality is a work in progress. Kontact notes windows look more like traditional text editing windows; they do not appear to be intended to be left around the screen like KNotes windows. Kontact does add a spelling checker, however. Even so, in your editor's opinion, KNotes works better as a standalone application at this time.

Tomboy

Tomboy is a GNOME and Mono-based note-taking application which attempts to provide both simplicity and useful features. Your editor has been using it for some months now.

Tomboy places an icon on the panel - not in the task area. Clicking on that icon yields a menu with the titles of the ten most recently modified notes, along with create and search options. Unfortunately, your editor seems to cycle through a set of about eleven notes, with the result that the desired one is often not on the list. Selecting "search all notes" brings up a dialog with all known notes and a simple search box. Typing text into that box trims the list of notes to those containing matches. There is no regular expression capability.

The escape key will dismiss a Tomboy window; combined with the panel icon, this feature allows for quick note updates.

A feature unique to Tomboy - at least, among the applications reviewed here - is the ability to link between notes. By highlighting a term, the user can create a new note using that term as its title; thereafter, clicking on the term will bring up the new note. There is also a backlink feature: the tools menu includes a "what links here?" item which will give a list of notes linking to the current one.

Tomboy has a fair number of options for decorating text with different fonts, colors, sizes, etc. For the most part, there is not much use for this capability in a note-taking application, but the ability to create bold headers can be nice. It's also useful to be able to strike out text to, for example, mark off completed items on a "to do" list. A long list of crossed-out items just gives more satisfaction than simply deleting them, somehow. Tomboy will also create bulleted lists when lines are typed beginning with an asterisk.

Notes can be printed (a feature not supported by all applications) or exported to HTML. There is a plugin mechanism which can be used to add interesting functionality; current plugins offer integration with evolution and bugzilla, for example. Tomboy also has a spelling checker which, by default, decorates notes with lots of obnoxious red underlines. It is rare that perfect spelling is required in a collection of personal notes, however, so your editor is pleased that this feature can be turned off.

Overall, Tomboy is a nice application; your editor's biggest complaint would be that its memory footprint is huge - even by GNOME standards. The use of Mono cannot help in this regard; it is hard to imagine which features in an application like this would really need the Mono framework for their implementation. With a bit less baggage, Tomboy would be nearly perfect.

BasKet

Finally, your editor played with BasKet, a KDE application which celebrated its 1.0 release on February 12.

Unlike other note-taking applications, BasKet does all of its work within a single window. At the top level, it maintains a tree of "baskets," each of which can contain any number of notes. Only one "basket" can be viewed at any given time. Baskets can be configured with up to three columns; notes are then lined up in the columns. There is also a free-format mode, where notes can be placed anywhere, even on top of each other. In your editor's opinion, the proper metaphor might be a bulletin board - each "basket" is a place where any number of things can be pinned and organized.

BasKet offers a great deal of control over fonts, sizes, weights, and so on. There is a mechanism for attaching tags to notes; each tag brings with it an icon and, perhaps, a set of heavy-handed color choices. Tagging an item as "work," for example, turns the text a sort of dark yellow color. There is an "insert image" operation which yields an empty note and a dialog on how BasKet cannot do image editing. Dragging an image over from konqueror does the expected thing - though your editor remains a little mystified by the concept of "moving" (as opposed to "copying") an image into the application. Baskets can also contain links, application launchers, and other surprises.

The end result of all this stuff is that the BasKet window quickly turns into a gaudy mess of wild colors and images. If your editor's word is not sufficient on this fact, the BasKet screenshots page should dispel any doubt. The BasKet developers are also enamored of animated effects, tooltips, and the use of audio signals.

The display of any given basket can be narrowed to items marked with a given tag. There is also a simple search mechanism which shows only the notes containing a given string. No regular expressions are supported, and the search only applies to the currently-displayed basket by default - though there is an option to make it global.

There is a feature by which baskets can be globally bound to shortcut keys, allowing them to be summoned by a single keystroke. Unfortunately, an attempt to play with that feature left your editor with a totally locked keyboard, a situation which made the writing of this article rather more difficult than it otherwise had to be. Logging in over the net and killing BasKet took care of the problem. One assumes this behavior is not part of the original design specification.

Summary

Of the applications reviewed, the first two (xpad and xpostit) are of relatively little interest. They reflect the state of the desktop art as it was several years in the past. Xpad is still a useful application, but it has been surpassed by others.

BasKet is an interesting attempt to do new things with notes. For your editor's needs, however, it is overkill. The whole point of note taking is to collect ideas together, track things to do, etc. It doesn't need images, colors, animations, sounds, and so on. BasKet seems to be more directly aimed at people who care about making their notes collections look cool. Your editor, who gave up any hope of looking cool back in high school, does not need BasKet's features.

That leaves KNotes and Tomboy. Either is an entirely capable application. The Tomboy feature set still seems like it is most directly focused on the note-taking application; the search feature is nicer to use and linking between notes is useful. But one could get the job done quite nicely with either of these applications.

Comments (47 posted)

Avoiding the tar pit

This Washington Post article is one of many expressing disappointment with Microsoft's Vista release, which is famously late and which has failed to live up to Microsoft's early promises. The article claims that the problems are not specific to Microsoft:

In this context, it behooves us to ask: is there a free software tar pit in our future? What can we do to avoid a grim future where we bog down, our software collapsing under its own weight?

Looking at the state of the free software community now, it is tempting to say that, so far, we have nicely avoided the tar pit. But have we? Here are a few dates from the past which may be of interest:

• The 2.2.0 kernel was released on January 26, 1999.
• 2.4.0 came out on January 4, 2001.
• 2.5.1 - the beginning of the next development series - was released on December 16, 2001

The 2.5 development series was stalled for almost one full year while 2.4 reached a state which actually approached stable. Overall, the process from 2.2.0 to a stable 2.4 took almost three years; the kernel was in a "feature freeze" state for about two of those years. This was a time when quite a few people - many of them kernel developers - felt let down by the development process. This, your editor would attest, was a tar pit era.

One might well argue that the kernel has not yet escaped that tar pit. Like Vista, we lack a shiny new next-generation filesystem; the only credible attempt at such a filesystem (reiser4) remains in a stalled, feature-reduced state. It seems likely, however, that most observers would agree that the tar pit has been left far behind. The kernel development process has been humming along at a high pace, delivering interesting new releases every few months. The same story can be seen in many other parts of the free software community.

If we accept that things have gotten better, it can be interesting to look at why. One hint can be found in the same article:

Any successful free software project must get good at fixing potholes; in the worst case, users (and distributors) will do the job for themselves. In a well-managed project, the people who are trying to improve the whole world will not get in the way of the pothole fixers. There is no single team, charged with all the development on a project, which can get bogged down in that way.

A "well-managed project" must find a way to keep whole-world improvements from stopping everything else, however. The older, multi-year kernel process did not always succeed on that front; the attempt to improve the entire kernel ended up bogging down the entire process. The new kernel development model, with its short release cycles, has caused some developers to complain that it is no longer possible to make major changes that require a long time to settle down. To the extent that this complaint is true, it should maybe be seen as a good thing. By only merging changes which can be brought to a releasable state within a month or two, the new process sidesteps the tar pit and keeps the development machine running.

One of the key suggestions in The Mythical Man Month is the formation of "surgical teams" to support the lead programmer(s). Some of the team members - such as the clerk who "keys in" the code - seem a little quaint now. But the idea that the people running the project (or parts of it) need lieutenants, documentation writers, tool makers, etc. still makes a lot of sense. Once upon a time, the kernel lacked much of that structure, with everything concentrating on a single developer - Linus Torvalds. Now there is a vast network of lieutenants. Quite a few developers focus their effort not on the kernel, but on the tools used by kernel developers. All that's missing are the clerks - and, perhaps, the documentation writers.

One of the biggest anti-tar pit technologies used by the free software community would have been hard for Mr. Brooks to imagine back in 1972: multiple, independent development teams. Any project of any size has a wide range of independent, sometimes conflicting development efforts happening at the same time. If one group bogs down, the others continue unhindered. The process may seem inefficient, given that a significant portion of the work which is done may never survive to a stable release. Throwing away code can be painful, but it is far less so than throwing away the entire project.

Peer review is also missing from the Brooks landscape. But peer review helps to ensure one of the things he thought was vital for a successful project: a clear conceptual architecture for the project. That architecture may take a surprising form: few free software projects have the sort of extensive design documentation that he probably had in mind. But a crowd of reviewers can help to ensure that new code is consistent with the principles behind a project - and that it is maintainable into the future. In this context, it is notable (and worrisome) that an increasing number of proposed kernel features are finding themselves stalled by a lack of reviews.

Finally, one should note that free software projects have mostly learned a sure-fire way to avoid a failure to live up to their promises: they don't make any. Vaporware tends to be scarce in this community; either the code exists or it does not. Very few projects are truly controlled by one corporation, so companies are also restrained in the promises they make about future releases; they are in no position to ensure that those promises are fulfilled. The relative freedom from marketing-driven promises helps free software projects avoid disappointments - but it also helps them to focus effort on objectives with a reasonable chance of success.

To argue that the free software community is immune to the problems of large-scale software development would be foolish. For all their growth, many or most components of a system like Linux are still a fraction of the size of their equivalents on certain proprietary systems. As our code base grows, there will undoubtedly be new challenges for those who would continue to develop it. But the free systems we have today must certainly far exceed the size of System/360 when Mr. Brooks was managing it, and we would appear to be going strong. With widespread community participation, improving tools, and the willingness to change our development models in response to real-world problems, we should be about to stay out of that tar pit for some time yet.

Comments (57 posted)

Page editor: Jonathan Corbet
Next page: Security>>