...making Linux just a little more fun!

<-- prev | next -->

Outliners and Mind mapping

By Jimmy O'Regan

Outlining and mind mapping are two ways of representing information. Both are useful for brainstorming and note taking (among other things), but most importantly, both are excellent ways of organising information. It should come as little surprise that organising information is important to programmers, and, because Linux is the operating system of choice for the discerning programmer, there is a wealth of software available to assist with these tasks.

I decided recently to get my life in order. Part of this was accepting that not all self-help material is rubbish. (For as long as I can remember, my father has been a devoted reader of self-help -- reader, not follower -- so I've been soured on the whole concept since my teenage years). Another part is simply organising myself.

One of the habits I'm trying to break is the habit of keeping notes on scraps of paper or in random text files scattered around the place. Outliners and mind maps are useful in the quest to add context and relationships to these otherwise random pieces of information, and have been working out well for me so far.


Outlining is a useful method for both note-taking and brainstorming. An outline is a list of ideas, which are grouped by sub-topic in a hierarchy. When writing an outline, only the key points are used, which are later expanded upon if writing.

The above paragraph as an outline would look something like this:


Outliners are a type of software that allow the user to write a document as an outline, to add detail to each point, and to hide that detail so further points may be added.

Most modern word processors have outline facilities -- the "Headings" view in OOWriter's "Navigator", for example. Although there are standalone outliners available, such as Think, the most interesting outliners around are those for Emacs and Vim.

Emacs Outline mode

XEmacs in Outline mode

Emacs comes with an outline mode. This uses a very simple text format: headings begin with an asterisk, and any text between headings is counted as the text belonging to that heading. If the text of a subheading is folded, this is shown as an ellipsis (...) after the heading's title. (example)

* Top Level Heading

** Sub heading

This text will be hidden if the sub-heading is folded.

** Sub heading 2
*** Sub subheading

The Vim Outliner

Vim Outliner

The Vim Outliner is, in my opinion, the best outliner available for Linux. (However, this is probably because I use Vim as my main editor: I prefer Emacs, but not after the beating Mandrake gave it). Like Emacs's outline mode, it uses a simple text format (example):

Top Level
    | Text 
    Another sub-heading
        | More text

Like Emacs's outline mode, TVO allows headings and subheadings to be folded. (Well, it would have to: otherwise it wouldn't be much of an outliner). Different heading levels are colour-coded; it's best to name an outliner file with the extension .otl, so Vim will know to do this.

While reading about outliners on the Net, I found a DOS outliner, ThinkTank, from 1987. This uses a simple text format that is easily converted for use with Vim Outliner.

Mind Mapping

Mind mapping is a way of representing information developed by Tony Buzan that takes advantage of several aspects of how the brain processes information. At its most basic, a mind map is similar to an outline in tree form -- a tree turned on its side, using roots as well as branches, but still a tree.

A mind map starts at a central concept. Top-level sub-topics branch out from that on either side, lower-level branches from those, and so on. With a paper mind map, when you come to the edge of the page, you simply glue a new page to that edge and continue.

So far, not much different to an outline.

An effective mind map makes use of different colours for each branch: This makes each main sub topic stand out more, and assists the brain in processing the data. It's also recommended that, where possible, a mind map should have pictures: "A picture is worth a thousand words" may be a cliché, but it's true.


While I'm talking about outliners, I should probably mention OPML, which is best known as the standard format for swapping feed subscriptions.

OPML stands for Outline Processor Markup Language. It has a very simple structure: As with HTML, there are "head" and "body" sections. Also as with HTML, the head section is used for meta information -- tags like "title", "dateCreated", "dateModified", "ownerName", and "ownerEmail" are self-explanatory; "expansionState" is used to contain a comma-separated list of the outlines that are expanded by default; "vertScrollState" contains the number of the line that is to be displayed (after outlines have been expanded); "windowTop", "windowLeft", "windowBottom", and "windowRight" are used to set the window state.

In the body section, there is only one tag - "outline", which can contain other outline tags, for the various levels of headings. The outline tag can have any attribute, though "text" is common. Most of these tags are ignored by feed readers, though, because they mostly look for a link and a title. I've included a sample.

Vim Outliner comes with a Ruby script that converts OPML to its own format - I've also included sample output: feeds.opml, sample.opml.



FreeMind is an open-source mind mapping program. It's written in Java, so it runs fine on Linux. Freemind has several features that those who are familiar with mind maps would expect; text and branch colours may be changed, images may be added to nodes, and there are several stock icons that can be added to branches or nodes as mnemonics.

Although the developers say that FreeMind does not create mind maps exactly according to Tony Buzan's original idea, it's close enough as far as I remember. It does, however, add some extra features that are not possible with paper-based mind maps: Branches and their nodes may have hyperlinks attached to them, and mind maps can be exported as HTML.

Mindmap with embedded graphics

FreeMind is easy to use: To add a node to a branch, press the 'Insert' key, and type. To change a node into a branch..., press the 'Insert' key. Nodes and branches can be cut and pasted; individual branches can be exported as HTML as well as the entire mind map; all options for formatting the node/branch are available by right-clicking on it. As with an outliner, branches can be collapsed (or expanded) by pressing "Space", and nodes can be easily navigated with the arrow keys.

Two things worth mentioning are that inserting a graphic (by choosing Node->Set Graphic from the context menu, or by typing Alt-K) replaces any text that was in the node; the other is that you can show that two nodes are related, even if they are in different branches, by holding Ctrl-Shift and dragging and dropping one node on top of the other. This draws a line between the two, which happily does not cover the text of any nodes in the way.

I've included some examples which show how I've used FreeMind -- mostly for summarising information, like when I wanted to find out about CIFS, or about comedy writing (though that, in turn, was based on an outline I found on the Internet), though I also used it to represent the decision-making process behind my haircut, to represent my bookmarks (see below), and to just have a set of ridiculous-looking bubbles. I've also added a second version of comedy writing that shows the difference having links between different nodes makes.

Delicious Mind

Delicious Mind is a Python script, available here that converts entries in del.icio.us to a FreeMind mind map. (I've included a local version that follows del.icio.us's request that scripts identify themselves, as well as my own version that generates rdf -- thanks are due to Ian Oeschger, who for allowing me to publsih my version).

For those who don't know, del.icio.us is an online public bookmarking system that has superceded the browser's built-in bookmark facilities for many people. Del.icio.us entries are not filed in folders like traditional bookmarks; instead, each entry is tagged with keywords, from which delicious generates a list of folders.

Del.icio.us also allows users to see who else has bookmarked each entry, as well as providing folders of popular tags, which contain items from each user who uses that tag. Del.icio.us also provides feeds, so people can subscribe to each other's bookmarks. Items may also be sorted by date, for a particular user, or for all users, and the main page contains a list of the most recently added bookmarks.

Del.icio.us provides a public API so people can easily access and manipulate their own bookmarks from scripts. Delicious mind takes advantage of this; it takes a list of tags, which are then defined as second level branches, and populates them with nodes of each bookmark in that category. (XML fans can rejoice: del.icio.us sends its information as a simple XML format that can easily be processed with some simple xsl).

As well as providing a way of visualising your bookmarks, this can be coupled with FreeMind's HTML export to maintain a local copy of your del.icio.us bookmarks -- like all popular Web sites, del.icio.us tends to suffer occasional periods of down time. (Have a look at the HTML export of this file compared with the del.icio.us version).


[BIO] Jimmy is a single father of one, who enjoys long walks... Oh, right.

Jimmy has been using computers from the tender age of seven, when his father inherited an Amstrad PCW8256. After a few brief flirtations with an Atari ST and numerous versions of DOS and Windows, Jimmy was introduced to Linux in 1998 and hasn't looked back.

In his spare time, Jimmy likes to play guitar and read: not at the same time, but the picks make handy bookmarks.

Copyright © 2004, Jimmy O'Regan. Released under the Open Publication license unless otherwise noted in the body of the article. Linux Gazette is not produced, sponsored, or endorsed by its prior host, SSC, Inc.

Published in Issue 108 of Linux Gazette, November 2004

<-- prev | next -->