RE: [unrev-II] Multiple Parents, Slash and Backslash

From: Garold L. Johnson (
Date: Wed Jan 03 2001 - 02:37:43 PST

  • Next message: N. C a r r o l l: "[unrev-II] Seeking definition for "DOM""

    -----Original Message-----
    From: Eric Armstrong []

    In conversation with Eugene, he's been asking
    the question: Are multiple parents for a node
    really necessary? Basically, if that concept
    adds complexity, maybe we should plan on not
    implementing it.

    I have felt that it was vital, but so far have
    not presented a compelling enough use case to
    settle the argument. This message is an attempt
    to do so. (And it led to another interesting
    insight that prompted me to jot down my thoughts.)
    <BIG SNIP>
    Multiple parents for nodes translates to clones or references – the same
    node can exist in multiple places in the “hierarchy”.

    Unix supports links to files and to directories, allowing the same file to
    exist in multiple places. Put it in the project that spawned it, into
    folders for tools that use it, into a current work folder, or move or add
    links as a file moves through a workflow process.

    I put a folder in my start menu for web tools. In that folder I place
    shortcuts (the closest Windows comes to links) to all of the various tools I
    use when working on HTML and web support. Then I place a link to the folder
    on my desktop to provide rapid access to a set of tools which are installed
    in yet another place in the directory structure.

    Literate programming editor (LEO)
    Edward K. Ream has written an outlining editor for doing literate
    programming (LEO ). The editor is patterned on an outliner called MORE done
    by Dave Winer who later did Frontier. Ed and Dave are convinced that an
    outlined requires clones.
    In use, as Ed begins to think about a feature, he builds a description of
    the feature in a features section. As more aspects of the feature emerge,
    they are added to the feature list.
    When it comes time to plan a release, features are reviewed and some are
    selected for partial implementation. This uses clones of the appropriate
    nodes from the feature description.
    As the time arrives to work on the implementation of a certain feature, it
    gets cloned into the ToDo list section. As code sections are identified,
    nodes in the ToDo list section describe the changes needed, and the code
    sections are cloned into the list.
    Now he can work from the ToDo list making changes to the cloned code nodes,
    which changes the single node in its place in the code. Test entries are
    created in the ToDo section as the changes are made.
    When the tests are complete, the nod form the ToDo section is moved to the
    change history section for the upcoming release.
    If defects are discovered later, the node can be cloned back into the ToDo
    list and all changes reviewed.
    Clones are essential and very valuable.
    MaxThink is a DOS outliner and one of the best IMO. It supports clones.
    Ecco is an outline based PIM with folders as an organizing concept. An entry
    is owned by a specific folder but may be cloned to others as needed. When an
    entry is cloned, the ancestors are shown in a different color and cannot be
    edited in the target folder. This makes it possible to plan a project in one
    place, put pieces of it into folders for the people who have to work on it,
    and place [Garold L. Johnson] another clone in the type of activity (phone
    calls, letters, etc.) and yet another clone in the schedule. Add priority
    folders and it now becomes possible to organize your activities in as many
    ways as is convenient. You can look at the project, the people, the task
    type, the priority, the status – whatever works.

    How humans organize
    We organize information into as many different structures as necessary,
    focusing on the structure that works best at the time, depending on our use
    for it. Every real thing fits into as many taxonomies as its attributes
    support. We organize in multiple hierarchies. This is one of the reasons
    that some people consider multiple inheritance to be essential to object
    oriented programming.
    One of the common filing systems recommended uses a primary hierarchy for
    physical filing while placing indexes at all other paths that are needed. If
    you start looking for something, follow a path and don’t find it, you go
    back and add references to the path you tried. Over time, everything that
    gets used at all frequently get all of the common access paths defined so
    that the item gets found from any reasonable starting point.

    I conclude that multiple parents, clones, references or whatever we call
    them are an essential part (as opposed to an accidental part) of knowledge
    management, and are thus a requirement in any serious system.


    Garold (Gary) L. Johnson
    DYNAMIC Alternatives <> <>

    This archive was generated by hypermail 2b29 : Wed Jan 03 2001 - 03:01:25 PST