Re: [cfgeeks] [Fok] IAJT

classic Classic list List threaded Threaded
1 message Options
Reply | Threaded
Open this post in threaded view
|

Re: [cfgeeks] [Fok] IAJT

Steve Litt
Keven et al,

I'm copying the VimOutliner list for reasons that will be obvious when you
read my response.

On Wednesday 25 February 2009 08:35:20 am Kevin P. Inscoe wrote:

> John Mayson wrote:
> > http://stuffwhitepeoplelike.com/2009/02/24/122-moleskine-notebooks/
>
> I am not sure why the Moleskins became trendy (some time in 2003 is when
> I first noticed it) but I used to carry a journal book around at M/A-COM
> and that was my wiki. Indispensable because you could look back at who
> asked you to for what weeks later. Have notes on technical things etc..
>
> anyway fast forward to Florida (1987). I still had a journal but working
> at the newspaper I didn't use it quite as much. When I arrived at
> Coleman I started using it again (still had writing from 1987 even) but
> then I became more electronic built my own web site and just started
> storing files. That's when it all fell apart because there was no
> organization to the files and I would forget that A) where they were and
> for what and B) that I had even taken notes. Finally at Convergys I
> embraced the Palm and the Franklin Covey system but that really had more
> to do with tasks. Then finally this century I started playing with wikis
> and discovered GTD. and life got better again. Now my ipod (plus wikis
> plus various web sites) has become my moleskin.
>
> But what I still lack is a good indexing system. I have tried using
> Dewey, hierarchies (where I am now) and of course tagging. Lately I have
> begun playing with mind mapping systems but these are based on single
> construct, project or thought. Not good for sharing but immensely useful
> for me finding stuff in my sea of notes. This is what I wanted to do
> with beljar. You link seemingly non related media, files and hyperlinks
> into bels (like java jars) not unlike Lotus Notes nsf files. Then each
> bel is a single construct, project or thought. Like let's say I want to
> store everything about bluetooth. I could create a bt.bel file which
> would have links to every possible article, files or media to this
> topic. But then how do you catalog that into GTD style meaning full
> tasks? Very difficult indeed. Try writing scanner or frequency databases
> some time. Do you make lists based on locale, county and state? Or geo
> lat and long? Or both? What about overlap? What about statewide or
> nationwide systems? Internationally used frequencies? It's a pickle.
> Universities have expert systems on this kind of thing but very complex.
> So fat tagging is the best middle ground I have found.

Hi Kevin,

You might want to check out VimOutliner (VO to its friends).
http://www.vimoutliner.org. It's an outline processor built from the ground
up for authoring speed.

VO has interoutline linking, so you can combine all your outlines, all over
your disk, into a single knowledge tree. I do this, and my top level outline
is called /d/otl/master.otl.

VO has executable lines. Consider the following line in a VO outline:

_exe_mozilla-firefox http://www.youtube.com/watch?v=rhF-Mqn-HEQ&NR=1 &

When you cursor to that line and press the ,,e key sequence, it brings up the
song "Island of Dreams" in Mozilla. Executable lines are a way to link
absolutely any content into your single knowledge tree.

There are several people on the VimOutliner list using VO for GTD, and they're
making more discoveries every day.

This brings us to your point, very well taken, that a given outline
manipulated by an outline processor operates on a single construct, project
or thought. This, of course, is a necessity limitation because an outline is
a hierarchy, meaning every node has only one parent. Nevertheless, there are
some workarounds.

In your bluetooth example, you could have a bluetooth outline, a cellphone
outline, and a Lego Mindstorm outline. They could also have "see also"
interoutline links to each other. Crude but somewhat effective.

As far as your frequency database, that should be an application driven by a
relational database, no iffs, ands or buts. You could sort or select by any
column; locale, county, state, geo lat and long, statewide, nationwide.

Then you can kinda-sorta finnesse an outline into multiple dimensions. I do
that with "bring outlines." A bring outline is the three tree outline you
make several days before a business trip, where you categorize and list every
single thing you need to bring. You also catigorize and list every single
thing you need to do before leaving. Those two trees drive the creation of
the third tree, the buy tree, which, because it's organized by store, makes
for a very efficient shopping list. All of this in enhanced by VimOutliner's
checklist feature, so as you check off items percentage completion on their
containing subtrees go up. When the top levels are 100%, you're free to
leave.

BUT...

There's some stuff you absolutely must leave til a half hour before you drive
to the airport, and you don't want that stuff confusing everything else. So
what you do is mark those things with %lastminute, like this:

[_] Jeans %lastminute

A simple grep -v filters out all the %lastminute items and the checked items
(with an X between the brackets), so you get a list of stuff you should be
working on right now.

Then you can build a hierarchy within a hierarchy. Check this out:

        [X] 100% Jeans @body %lastminute
        [X] 100% wallet @jeans %lastminute
        [X] 100% ResFolder1 @carryon
        [X] 100% ResFolder2 @smallcase
        [X] 100% CourseFolder1 @carryon
        [X] 100% CarryOn @cartrunk %lastminute
        [X] 100% SmallCase @cartrunk %lastminute
        [X] 100% BigCase @cartrunk %lastminute
        [_] 0% Notebookcase @cartrunk %lastminute
        [X] 100% trainbox @smallcase
        [X] 100% toiletbox @smallcase

The preceding is a list of containers -- things that can hold other things (my
jeans have pockets). This list of containers becomes the fourth tree in the
outline.

So, the jeans go on in the "body" container. The wallet container (which holds
money and license and credit cards) goes in the jeans container. The
ResFolder1, a manila envelope containing copies of all my reservations for
parking, plane, rentacar and hotel, goes in my carryon case, which goes in my
my cartrunk container. In the preceding list, the top level containers are my
body and the car trunk -- neither of which go "in" anything else.

Armed with the hierarchy of containers, the items tree of the outline lists
where each item goes, like this:

                [X] 100% 8 Coursewares @trainbox
                [X] 100% Stereo Mental Model @coursefolder1
                [X] 100% Flight reservation @resfolder1

That way, the minute I get an item in its immediate container, I mark it
complete, knowing that the actual assembly and packing of containers can be
left unmarked until they're assembled and packed. Also, doing it this way
means when I get to the destination, I know EXACTLY where to find a specific
item.

Like I said, this is a kludge to impose multidimensionalism on an otherwise
pure hierarchy, but it's effective.

The reason it's effective is because of the native format of a VimOutliner
outline. It's nothing more than main items having no tabs, their immediate
children having one tab before them, their grandchildren having two, etc.
Like this:

Bring
        Clothes
                Suit
                Ties
                        Red
                        Yellow
                Shirts
                        Dress
                                Blue
                                White
                        Casual
                                Hoodie
                                Polo
                        Under (5)

What that simple structure means is you can have your way with it using things
like grep, grep -v and the like. For more complex views of the outline, you
can easily parse it with Perl. I've even gone so far as to create a (GPL)
tool called Node.pm that makes it trivially easy to turn an outline into an
in-memory node tree (very similar to a DOM tree, but much simpler), and then
process it with a walker object. I also have a Ruby implementation, and both
are available for download on Troublehsooters.Com.

You mentioned mind-mapping software. My 20 minute flirtation with freemind
tells me that mind-mapping tools are just outline processors with a graphical
presentation. That graphical presentation is great for recognizing fairly
simple concepts, but breaks down mightily in, let's say, a structure with a
thousand items.

If mind mapping software can handle two items pointing at each other, or three
items pointing circularly, then I withdraw my statement about them just being
outliners with graphical interfaces, but my statement about them not being
practical with 1000 items still rings true -- what's the use of graphical
representation if you can't see it "at a glance?"

Anyway, take a look at VimOutliner at www.vimoutliner.org. I can't promise
it's what you want, but I CAN promise you it's the fastest way to get
information from your brain into an organized file format.

SteveT

Steve Litt
Recession Relief Package
http://www.recession-relief.US

_______________________________________________
VimOutliner mailing list
[hidden email]
http://www.lists.vimoutliner.org/mailman/listinfo/vimoutliner