My ideas about possible MaxThink-mode
=====================================

:date: 2002-09-20T06:00:00
:category: computer
:tags: vim, emacs, outliner, design

(This is a very old draft of a paper I have sent to RMS asking
for his feedback on extension of the Emacs’s ``outline-mode`` to
support what I remembered from MaxThink_ by Neil Larsen;
org-mode_ didn’t exist yet, and not long after that I have met
VimOutliner_ anyway).

First of all, when I have contemplated about this report on
MaxThink, I have came to conclusion, that just remodelling of
Outline-mode probably shall not be enough (I am not a programmer,
so I may be wrong).  For example, I guess that some special
(certainly text-based) data format should be invented. Tree with
around hundred levels would be very inefficiently saved when
every level would begin with hundred of asterisks.

Another substantial difference (IMHO) is that in Outline-mode
branches are deemed to be just headlines and majority of text is
supposed to be body text (aka leaf). On the other hand, there is
nothing like body text in MaxThink, only leaves and each leaf can
have a subtree (for the sake simplicity I do not make in this
document a difference between individual leaves and subtrees --
each leaf is possible subtree, maybe with none children). Another
idea is that leaves tends to be *very* short for better movement
and processing (just couple of lines, maybe paragraphs when it is
a quotation or like).

Basics
------

Fast movement
~~~~~~~~~~~~~

The very idea of Mr. Larsen (author of MaxThink) is that browsing
through any set of data should be as fast as possible given the
intuitive memory (or what's the name) expires in some two seconds or
so. Therefore, in order to make really intuitive knowledge base, you
need to be able to browse it *fast*. I mean, really fast.

Therefore, his MaxThink (as well as his other program, Houdini,
for making hyperlinked knowledge networks—but, it seems to me
to be much less useful than MaxThink) uses modal design. In
browsing mode you need only arrow keys (no Ctrl-, Alt-, or
anything else). When your cursor is on the proper leaf of the
tree, just press [TAB] and you are in very simple editor for the
particular leaf (with wrapping, but otherwise, just plain text).
Out of this mode you get either by [ESC] or by making other leaf
(see below for description of hotkeys F7-10).

Certainly, I suppose that maxthink-mode (or whatever will be its
name) shall follow EMACS standards of user-interface, but it is
necessary to keep *speed* of browsing and simplicity. In the
further text I shall describe MaxThink as it functions now.

View
~~~~

There is only limited number of levels on the screen in a given moment
(you can change it while browsing by Ctrl-[<-] amd Ctrl-[->] for
collapsing or expansion), so when you switch to any deeper /higher
level, whole view shifts so that parent of actual level is on the top
of the screen and as many of its children as fits to the screen below
(slightly intended and numbered).

Every leaf in the whole tree has its address based on the decimal
numbering of leaves (top leaf is 0; the first level leafs are
0.1, 0.2, etc.; the second level leaves are 0.1.1, 0.1.2, 0.2.3,
etc.). Relative addresses and addressing of group of leaves are
both possible. Whenever possible user can select item by arrow
keys movement, rather than by just typing address(es), which is
also always possible.

Certainly, there is unlimited depth of the tree (or very high, I
have never seen a tree deeper than 100 levels), so that asterisks
(as in current Outline mode) are certainly not satisfactory
solution and some more advanced one should be found (e.g., whole
actual address of the actual leaf may be shown on a mode-line and
leaves on one level should be numbered by ordinary numbers or in
Chicago-manual-of-Style-outline-numbering style; A.I.1.a. etc.).

There are also some kind of bookmarks available (similar to ones
in Netscape or any other www browser) and symlinks (where a
leaf is just a mirror-image of another one).

Inserting new leaf
~~~~~~~~~~~~~~~~~~

While the cursor is on a leaf you can press couple of hotkeys to
create new leafs (F10 for sibling below the actual leaf, F9 one
above, F8 is for child, and F7 for brother of parent below the
parent's leaf). The same options are available from a menu, but
hardly used by myself.

Any number of leaves can be selected and copied/moved/deleted
etc. to make parents/siblings/children of target leaf.

Advanced functions
------------------

What makes MaxThink something more than just powerful outliner
are advanced functions for fast and mighty reorganization of
tree. Sorting is obvious (on selected leaves or all on the given
level of current subtree). Dividing/joining of actual leaf (or
selected leaves) by words/lines/paragraphs is self-describing.
Other simple option is randomizing given leafs on one level
(sometimes, when you cannot find a solution in given order, it
helps to mess things and start afresh).

There is also computer aided binsorting (i.e., putting things in
different bins, no relation with a type of sorting algorythm).
Try to imagine, that you have couple of hundred leaves long list
to be organized in separate categories. You can use cut/paste
method but it is too slow. You can also, create couple of new
leaves in the top of the list and mark them as bins. Than you
start the function BINSORT and you are asked in sequence for
position of each leaf (remember, categories as well as any leaf
in MaxThink are numbered so one tick on keyboard is enough to say
which category is the one, if there is only up to nine of them;
but you can use arrow keys as well), then it is moved to so
created category (i.e., subtree). I have binsorted five hundred
topics in beautiful outline in a hour. Try it with plain cutting
and pasting.

Another function is simple. It's called LOCK and you just staple
a current leaf (or subtree under current leaf) to your cursor and
moves with it until you find the best position for it and let it
be there (by [ESC]).

There is also a function called GATHER. When you switch it on,
you can pick leaves up while browsing in some temporary memory
and than throw them in some new place (either with move or copy).

Another function is called PRIORITIZE (isn't it beautifuly
bureaucratic word! :-). It is based on presumption, that it is
much more simple to find *one* most important thing in the given
list of items, than to sort them. So, this very simple function
asks you which of items from the list is the most important one
(BTW, every function has usually some sensible defaults—in
this case list of all items on the current level of current
subtree). Then it hides your pick and asks you again, ... until
the list is sorted. Incredibly simple and stupid, but very
efficient (especially with huge lists, which are really difficult
to organize).

Sometimes it is usefull to mark some items on huge list (here
MaxThink makes things simple by just inserting ten equal signs)
and recreate an outline by one operation where all non-marked
leaves are subtopics of makred leave directly precedent (these
equal signs are of course deleted when non-needed). Inverse
function is available as well.

Some funny things
-----------------

There are some other things as well. Additional program makes a
tree from any directory and its subdirectories on your harddrive,
so you can analyze it with MaxThink. You can add by a hotkey
date/time while editing a leaf. Program is able to divide whole
tree while printing on more sheets of paper, so you can setup
(e.g., in your local gym) with a tree of any size. Tree can be
exported to some wordprocessors (MaxThinks has export to
WordPerfect and M$-Word, but in a free world it just cries for
export to LaTeX).


.. _MaxThink:
    http://maxthink.com/
.. _org-mode:
    http://orgmode.org/
.. _VimOutliner:
    http://vimoutliner.cepl.eu/