Peter's Blog

Latest candidate in my pursuit of the ideal Outliner is TreePad. This is the most appealing so far:

• two-pane outliner: tree hierarchy on the left, node contents on the right. Simpler than Microsoft OneNote with it's confusing mix of tabs levels.
• The node contents are rich text that can contain formatting, images, tables (unlike OneNote) etc. Node editor is virtually a word processor.
• Nodes may contain hyperlinks to executables, web pages, other nodes in other treepad documents (unlike OneNote and better than leo's cloning which only works in the context of a single document). Hyperlinks go in article body, unlike Leo where they go in the tree node title, not a good place to put it in my opinion.
• Tree nodes may have an icon associated with it. Leo loads it's selection of icons very slowly.
• Not the fastest program I have used: the help file is a 5M treepad document and takes a good time to load up (1.5G Centrino).
• Simple installation: one of it's features is that it can be installed on a USB flash key and carried around. I haven't found a licence agreement yet to tell me if it has to be licenced on each pc it is used on.
• Robust encryption. Dare I trust it with my credit card numbers and passwords?
• Can export in many formats including XML, OPML (which strips internal hyperlinks), html-ish files parsable by python. It is important to me that data can be extracted from any proprietary file format.
• Documents can be exported as entire websites, complete with Javascript driven tree. Kinda tempting to examine the possibility of organising a website around with this, carryng it in pocket, publishing it, searching it, refactoring it, writing it to pdf... I find blog notes the best place to record things but web interface is not the best editor. Could type stuff in here and bulk move it to the blog.

It is commercial (£20 ish) but it is very polished (unlike Leo).

Discovered LEO and editor with outlining and literate programming features. It is written in Python and has good support for writing python and C/C++ programs as well as java and other niche languages.

It looks interesting to me in that it allows a whole project to be organised in a free-form hierarchy. At the top level can be groups of files, within the files could be groups of related classes, with the classes methods may be grouped and with each method sections of code could be grouped. All groups are expressed as nodes in a tree. When the .leo file is saved it automatically creates the appropriate python files containing the 'flattened' code. This makes better organisation possible.

Thoughts on this:

• it would make a good basic outliner, ignoring the literate programming features.
• it has an interesting 'clone' feature which allows sections of the hierarchy to be referenced in multiple places. A simple example, if I have a node that describes someone called 'bill' I could put a reference to the 'Bill' node in a calendar node on his brithday, the christmas node under people to send christmas cards to, my hit list etc. In terms of organising code this has great potential: if I want to describe how a piece of code works, the description can link right in to the code being described, completely independent from the file/class/method structure imposed by the programming language.
• the files it creates have rather ugly markup added. This is there to support round-trip editing: the code generated can be edited and read back into the outliner. This is a really neat feature, making it possible to do the bulk of coding and tweeking in vim and just the structural organising in the outliner.
• the nodes in the organiser can reference URL's, making this a useful bookmark organising program. Nodes can reference other LEO files which could be a way to support very large projects.
• the .leo file format is XML making it parsable etc.
• LEO has a plugin system and is scriptable in Python: interesting.
• One of the plugins appears to allow VIM to be used as an editor, although I haven't tried that yet.
• All the LEO source and documentation is handled by LEO: that has to be some form of endorsement.

I find this interesting, the way that the source code can be embedded in the project documentation, organised in a nice hierarchy etc. The source files are surrounded by nice rich metadata in any way I can think of, no more being limited by the file systems directory hierarchy or the structure imposed by the programming language.