Peter:

Your "Think" program might be extended with some more "thinking 
functionalities", and also to be able to share outlines. That way, it would 
become a "coThink" program.

As you are writing it under the GPL, it might eventually become very widely 
used. I believe there is a lot of "thinking" and "cothinking" that needs to be 
done in the World.

Here are some ideas. Please tell me what you think about them.

Regards,

Lucas

The data structure would be something like the following:

     Outline structure:

          Each topic would be in one line, with the "dependant" topics 
          following the "parent" topic.
          The "root" topic would have no leading star. All the other topics 
          would have one or more leading stars.

          It would look like this:

          root topic
          *chapter 1
          **paragraph 1.1
          **paragraph 1.2
          *chapter 2
          **paragraph 2.1

     After the leading stars (zero or more), there would be some optional 
     "structured information", and then the text of the topic itself.

     Initial "structured information":

          If after the leading stars there is a ".." it means that some 
          "structured information" follows:

          ========== Historical order and number of editions
          "..#num1.num2:" This means that the topic has historically been 
          written in some given order, expressed by num1. After the period, 
          num2 gives the number of editions of the topic (more than one 
          edition between two "saves" count as one edition).
          E.g.: "..#7.3:" would mean that the topic (say "chapter 2") was 
          created when the outline had 6 topics, and it has been edited 2 
          times since its creation.
          This means that topics can be moved around within the outline, 
          and edited - and the historical information is dragged with each 
          topic. This feature can be useful in mantaining one or more 
          translations of a "live" document, and of course for merging co-
          outlines.

          ========== Author information
          "..atext1:text2:text3:text4:" This gives the information about 
          the author: email address, name, date of creation, date of last 
          edition.
          Information about authors can be used or not, so that outlines 
          are co-thought with signatures or anonymously. When an author 
          gathers topics written by others - maybe to sort or summarize them - 
          he in fact becomes the author of the topic (or subtree) he is about 
          to write.

          ========== Permissions
          "..cXXXXX" This means that the topic (and all its descendants) 
          have some kind of restrictions for reading, adding, modifying, 
          sorting, and deleting the topic and its subtopics.
          The "XXXXX" part would be coded in a way similar to the file 
          information given by the "ls" command in Linux. If a given 
          participant has the required "level", he can do so many things to 
          the outline - otherwise, he can do less.
          This needs more thinking: types of user, types of co-thinking, 
          etc. FidoNet BBSes used to have user levels coded with letters.

          ========== Fences
          "..f" This means that the topic is a "fence". These are special 
          topics that act as boundaries within a list. With the "categorizing" 
          function, they become parents of the topics that initially were 
          their younger brothers. Subtrees can be "decategorized" (flattened) 
          with or without fences.

          ========== Personal notes
          "..x" This means that the topic (and its descendents) are 
          excluded from printing or viewing or sharing. This is the place to 
          keep personal notes.

          ========== Fast Jumps
          "..gX" This means that the topic has been marked as a "fast 
          reachable" topic. Maybe "..g1" is the to-do list, "..g2" is the aims 
          and goals list, etc. You get there simply pressing the digit 
          (provided you are not in "edit topic" mode).

     The topic itself:

          Within the topic there would be the text itself. Between the 
          "printable" characters, there can also be:

          - Instructions to the printer: bold, underline, etc. This could 
          be coded <b>like HTML</b>.
          - Links to external files (other outlines, plain text, graphics, 
          sound, almost anything) or URLs.
          - Embedded objects. This would make the data structure a bit too 
          cumbersome - but if objects are kept separately then a menu option 
          or a separate utility should detect dependencies in order to drag 
          dependent files when copying/moving/sharing the outline.

The functionalities would be as follows:

     Displaying the information of the outline:

          As the default, only two levels of the outline would be visible 
          at any given time. For instance, a heading and its subheadings. This 
          is called "focused thinking" - if each level is complete, 
          symmetrical or otherwise satisfying to the author, then the whole 
          outline is "done".
          The number of visible levels can be changed.

          As the default, the text of the topic is shown in full in its 
          proper place in the screen, and the "structured information" appears 
          at the bottom of the screen every time we move the topic pointer.
          As an option, only the first line of each topic can be shown (and 
          perhaps all except the first line if it has some kind of comment). 
          This way, we can get an overview of a group of paragraphs by seeing 
          only the first line of each of the paragraphs.
          The "structured information" cannot be edited as text, but only 
          through the menu options.

     Navigating the outline:

          Its easy and useful to define two modes of working with the 
          outline: "edit a topic" and "everything else".

          The second mode includes navigating the outline, which can be 
          done very easily with the four arrow keys: right for descendent, 
          left for parent, up and down for previous and next siblings.
          Within a given level, Begin and End take us to the first and last 
          topic in that level. PageUp and PageDown take us to the previous or 
          next "fence".

          Apart from this "local" movement, as many as 10 "far jumps" can 
          be defined using the "..gX" information. Outside "edit topic" mode, 
          pressing a digit takes us to the marked topic.

     Creating topics:

          After /Before /Under current topic.
          Splitting current topic in "edit mode" creates two topics.
          Dividing current topic (or selection of topics) into lines, 
          sentences or words creates many topics.

     Editing a topic:

          Some key/icon brings us into "edit topic" mode. We cannot 
          navigate - or can we? Perhaps when "harvesting" ideas I must read 
          many topics and meanwhile write the fresh one. Perhaps when in "edit 
          mode" we can navigate using control-arrows or control-digit - and 
          still keep the editting window in sight.

          Still not clear.

     Moving topics:

          Within the outline: rank, randomize, sort, basket sort; flatten 
          outline, categorize; move one by one, move selection.
          To/from the buffer: put, get, gather (vacuum cleaner metaphor).

     Managing files:

          Loading other outlines from a master OL.
          Save subtree as full OL.
          Load directory information as sublist.

     Thinking tools:

          A random word generator.

          Help, in hypertext format, about thinking and creativity tools.

          A programmable alarm clock to preset the use of my thinking time: 
          e.g.: 1 minute for creativity and 5 minutes for evaluation.

Some necessary utility programs would be these ones:

     Merging an "update" file: a central place receives new editted 
     versions of the "cooperative outline" (coOL), and merges each of them 
     with the master coOL. Then it sends the revised OL to the cothinker, also 
     by email (majordomo or similar).

     Creating a glossary: A parallel OL can be created by each user, that 
     lists every word in order, and has the address of each ocurrence (the 
     Think program might then be called with the address as a parameter, so 
     that the OL is loaded and the cursor placed in the appropriate position). 
     Noise words can be supressed from the glossary.

     Mantaining one or more translations of a document: the "..#num1.num2:" 
     information can help to keep track of changes, translate only the new or 
     edited topics, etc. This would be very useful for the manual of Think 
     itself!
