Peter's Blog

Redefining the Impossible

Items filed under outliners


I haven't looked into outliners much recently, since the microblog saga, but I have recently been playing with freemind which is more of a brainstorming tool than an outliner.

Bullet review:

  • written in java i.e. it's slow to boot up and uses lots of memory (i.e. lots of swapping on 256M system). Performance is ok once it is running.
  • Nice graphical display:
    images/PetersBrain.jpg
    the idea is that it is highly graphical to appeal more to the right side of the brain which likes pretty colours.
  • The graphic above was generated using a simple 'export as jpeg' option.
  • The map acts like a huge canvas. You scroll around the canvas by clicking and dragging (as per google maps) so you don't need to use the scrollbars (very nice).
  • Very responsive on the keyboard: return key to start new sibling which is more intuitive than it sounds. This would make it quite quick for note taking and it could be driven without the mouse.
  • Nodes can link to web pages, disk files etc. Annotate your hard disk!
  • It saves maps in XML format. There is potential here for generating maps in software for display.
  • maps can be put on the internet read only either as html (without the graphics, just trees) or graphically if the browser supports java.

I like to do these kind of diagrams for brainstorming so I may stick with this.


Filed under: outliners

Add a comment

I have some ideas for the note-taking and organising tool I want. My thoughts have been inspired by Dave Winer's OPML editor.

I started blogging as a way of organising notes but that has gone in an awkward direction: I write mini-articles and this takes time. What I am thinking of is the ability to just chuck down a sentence or two, maybe a web link, and just store it. Associated with these jottings would be a few tags that would enable me to organise them. The jottings would not necessarily have titles, I don't want to waste time thinking of a title. The intention of all this is to be light-footed, nothing to slow down the process of using it: the main reason I don't take down as many notes as I should is that I can't be bothered. The OPML editor is close in terms of being able to bang down notes with no titles but I have yet to explore it's categorising/tagging facilities.

One way I could use the OPML editor would be to compose an OPML file full of each days notes. I don't want to mess with a different file for each thing I work on, I'd rather use categories/tags to do that. At the end of the day the OPML could be consolidated into Drupal or whatever for archiving/viewing/editing as ultimately OPML is not a database. Posting articles directly into Drupal is too laborious, especially over the net: I don't want this to take more than a second or so. Another advantage of storing the articles in Drupal is that I can use my wilki syntax to add syntax highlighting.

I have to think about this some more.

Update: from the OPML Editor notes:

The core purpose of this program is to create outlines and share them with other people, in various forms.


Filed under: drupal opml outliners

2 Comments

Giving Dave Winer's new OPML Editor a try. It is cross between an outliner and a blogging tool. You can see my new blog here. At the moment it comes with free hosting but make the most of it because Dave has wisely made no commitments.

images/OPMLEditor.jpg

As a tool it looks like an update of Radio Userland. It supports html markup which is pretty much a must-have these days.

Posting through the editor is very quick and easy, I could be tempted by it, or maybe a way of importing the OPML into Drupal? I'll have to think about it. OPML is a nice file format, XML and all that, not proprietary or a binary black box.

It supports a kind of public outline which you can share with your buddies or, my preference, use to dump notes for home or work.

It is interesting, I'd play some more but unfortunately I've got to do babysitting sad


Filed under: blogging opml outliners

4 Comments

Two concepts I have been contemplating recently are starting to blur together: outliners and tags.

I have read of people who have moved from Outliners to Wikis as a means of organising their notes. I have found Wiki's rather simplistic and unattractive, especially as web-based editors are sluggish compared to desktop applications.

However, now I have changed my site to use awTags I see how tags can be used to implement a wiki. But this is better than a wiki: a link leads to a list of related articles rather than just a single page. In the manner of an outliner, an article leads on to a list of child articles according to which tag you follow. The article itself can be tagged with a number of different tags representing different concepts that the article itself can be filed under and these links can be regarded as parent relationships. This is just what TheBrain is trying to do: Mind Mapping but without the fancy graphics.

I have altered my wilki module accordingly and have used it right there. By typing in something as simple as

[wilki|tags/wilki]

I created a link to all my wilki module related postings filed under the wilki tag. Alternatively, I could have linked to the wilki introductory article and from there a reader, once they know what the wilki module is, can follow the wilki tag if they so desire.

This is all pretty abstract and I will have to see if it is actually of any use in the real world. On a practical level it will be easier for me to reference other articles by linking to the tag name, rather than trying to find the drupal node number of a specific article I am thinking of. The downside is that going to the introductory article is probably a better pattern to follow, especially as articles are listed in reverse chronological order, putting the most informative introduction at the very end.


2 Comments

Next in my Outliner quest is TheBrain. This is a radical looking outliner:

images/TheBrain.jpg

Each node in the diagram is called a 'thought' and it can have multiple parents, children and peers (not siblings, they can have different parents). This allows incredibly complex mappings of relationships to be created. For an idea of what it is like to use, try the WebBrain which needs java enabled in your browser. The mappings form more of an amorphous blob than a tree and so can model all kinds of things. It is more of a brainstorming tool than an outliner.

Review:

  • it is fun to use
  • it is easy to get lost
  • you can assign web pages, applications etc to thoughts, so they launch when you click on them
  • I tried mapping mail addresses to people thoughts but the mailto link was broken by the time it reached outlook.
  • A folder can be assigned to a thought, in which case 'virtual thoughts' representing the files in the folder appear in the map.
  • can export data as XML, although I haven't tried that yet to see how complete it is.
  • RTF notes can be assigned to thoughts. Unfortunately these cannot contain hyperlinks but they can contain OLE objects (remember OLE?).
  • It is easy enought to search for items or assign keywords and types to them. Tell the difference between people and computers in your map.

TreePad seems more a way of organising articles that TheBrain, which is a way of arranging thoughts and pushing them around as a way to see new relationships. It is interesting putting a family tree or company organisation chart into it and examining it from all angles.

I'm having fun playing with it. I came across other Mind Mapping tools in my exploration but TheBrain's totally unique UI appeals to me.


3 Comments

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).


5 Comments

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.


Filed under: leo outliners python vim

4 Comments

I like the concept of outliners, previously I used Bonsai but today I've been giving The Vim Outliner a try. It works as a very simple markup language and then adds syntax highlighting to make headers more visible. For example:

This is a Heading.
   This is a Subheading.
        | This is some text within the subheading.
        | Blah Blah Blah Blah
   This is another subheading
        | More plain text.
        | Blah Blah Blah

gets displayed like this:

This is a Heading.
    This is a Subheading.
        | This is some text within the subheading.
        | Blah Blah Blah Blah
    This is another subheading
        | More plain text.
        | Blah Blah Blah

(notice how I can use Vim's built-in syntax highlighting to html conversion to generate this).

This makes outlining in VIM very easy and the syntax highlighting helps readability a great deal. TVL defines some useful shortcut keys such as - and + to fold and unfold sections easily. The outline text is stored in .otl files and Vim's file type system automatically applies the outlining features to these files when they are opened.

I find it interesting to compare what is effectively a new markup language with other markup languages I have encountered such as reStructuredText and indeed I am writing this using my Wilki Module which is another markup language. These have all used markup on the headers and plain body text but in TVO the body text is both marked with a '|' character and the headers are plain text. This would make TVO files tedious to type except Vim has been set up to automatically insert the indents and the '|' character so it is easy to type away as normal.

Markup languages are most useful when they can be easily converted into other formats. The Vim Outliner comes with an otl to html converter written in Ruby (python ripoff programming language named after a Kenny Rogers song about a prostitute). It is not hard to do simplistic conversion in python:

   1  #
   2  # otl2html.py: convert .otl files to html
   3  #
   4  import re
   5  
   6  oREIndent = re.compile( '^(\s*)(\|\s)?(.*)')
   7  
   8  nHeaderStack = [ 0]
   9  nTextIndent = None
  10  
  11  for strLine in open( r'c:\tmp\try2.otl').readlines():
  12    oMatch = oREIndent.match( strLine)
  13    if oMatch:
  14      strIndent = oMatch.group(1)
  15      strTextLeader = oMatch.group(2)
  16      strText = oMatch.group(3)
  17    else:
  18      strIndent = ''
  19      strTextLeader = ''
  20      strText = strLine
  21    if strTextLeader != None:
  22      #
  23      # This is a text block
  24      #
  25      if nTextIndent == None:
  26        nTextIndent = len( strTextLeader.expandtabs(4))
  27        print "<p>"
  28      else:
  29        strText = (strTextLeader + strText)[nTextIndent:]
  30      print strText
  31    else:
  32      #
  33      # Dealing with header
  34      #
  35  
  36      #
  37      # Terminate text block.
  38      #
  39      if nTextIndent != None:
  40        print "</p>"
  41        nTextIndent = None
  42  
  43      #
  44      # Lets assume it's me and a tab = 4 spaces
  45      #
  46      nIndent = len( strIndent.expandtabs(4))
  47      while nHeaderStack[-1] > nIndent:
  48        nHeaderStack.pop()
  49      if nHeaderStack[0] < nIndent:
  50        nHeaderStack.append( nIndent)
  51      print '<h%d>%s</h%d>' % (len(nHeaderStack), strText, len(nHeaderStack))

Add a comment

Been playing with Radio Userland. It is a mixed bag of things:

  • a local web server, driving the main application through a web browser

  • a blogging tool. Type a post in a box and publish. It gets uploaded to Userland's servers and there it is.

  • a news aggregator, it aggregates RSS feeds for perusal through the browser

  • Content Management System: put files in directorys and they get rendered and uploaded automatically.

  • Scripting tool

  • Outliner

Good points:

  • Easy blogging for newbies

  • Can email it to post blogs

  • Easy to knock up a web site

  • The outliner has neat features like linking to web pages or other outlines which can be opened in place.

  • It is heavily scripte.

Bad points:

  • I had to reinstall it because the upload got broke

  • The scripting language is clean but it's no Python

  • The outliner is not nice to use. It is a fairly crude app by modern windows standards. Bonsai is far nicer to write in.

  • The outliner is used to edit the system scripts: no syntax highlighting and all nodes collapsed by default. I find this hard to read. I miss Vim.

  • Their web servers can be very slow: uploads can time out.

  • Uploading is all done automatically in the background so you have to keep looking at an events page to see if it has worked.

My head says dump it but something in my heart wants me to keep it. If it ran on linux I probably would.


Add a comment

Natara Bonsai Outliner, 1st Impressions: I like it. Far slicker than Progect & ShadowPlan. Very good import & export, desktop tool is less hacky than SP & the licence allows me to use it at work & at home.


Filed under: bonsai outliners

Add a comment