The Outliner of Giants
  • Your outlines
  • Support
Your outlines
  • An outline about outliners!
    • Outline Processors are a class of computer program that mix the functionality typically associated with a Word Processor - such as the ability to edit text and manage its layout - with functionality to give a tangible structure to interrelated blocks of information - more commonly associated with a database. Outline documents are primarily characterised by their deeply hierarchical structure, with functionality that enables the 'folding' and 'unfolding' of their individual sections, allowing the author to focus on just the block of information that they are currently working on. This contrasts sharply with a traditional word processor document, where the entire text is laid out in a linear fashion, meaning that the user must scroll from top to bottom to reach the required section. Outliners have a long history - going back to the very beginnings of personal computing - and outlining functionality is now commonly integrated into a wide range of applications for writing and managing information.
    • On the nature of outliners: What is it that makes an outliner an outliner?
      • Outline Processors are defined by the functionality that they offer the user, the most striking aspect of which is their deeply nested structure. Here we will examine the array of properties typically associated with outliners, and the functionality they afford those using them for their work.
      • Children stay close to their parents: each node has a single parent, and can have none to many children.
        • Changes affect the whole family: Cloning, copying, moving or deleting a node affects all of its children too.
      • The structure of ideas: the multi-dimensional nature of outliners supports the user in creating a deeper representation of their ideas and understandings.
        • Creating a node substructure: such as through the use of columns or tables, facilitating the display of structured data within the context of the wider hierarchy of the outline.
        • Breadth and depth: notes and attachments add another dimension to the information that can be represented by a node.
      • Zooming in and out: the interface can easily be modified to enable the user to gain the required overview of the information contained within the outline.
        • Focusing on just-this-node: hoisting nodes allows the user to focus their attention on a single node or branch of the outline's structure, moving all others into the background.
        • Gaining a high level overview: hiding unnecessary information is achieved by folding un-wanted branches, or by separating the outline's structure from its content using panes.
      • Research, reorganise, rewrite: Despite its formal structure, the outline should remain malleable, enabling the user to easily re-organise the information that it contains based upon new understandings.
        • Traversing the hierarchy: individual nodes can be assigned a new parent, such as promoted to the existing grandparent or demoted below one of the its siblings.
        • Bringing order to the chaos: manual or automatic sorting provides the user with a simply way to order a node's children within the context of their siblings.
        • Mark-and-gather: the user can mark individual nodes, no matter where they are located within the outline's structure, gathering them together in a single place through copy or move.
      • Leaving a trail of breadcrumbs: marking enables the user to keep track of nodes that they may wish to return to later.
        • Highlighting for attention: using coloured labels distinguishes one node from another, such as those of a particular priority or status.
        • Ticking off completed work: a checkbox provides the user with a way of keeping track of completed tasks, and those yet to be done.
      • Making nodes stand out from the crowd: formatting individual nodes allows them to be visually distinguished within the context of the wider outline.
        • The rules of appearance: enable the user to specify formatting rules that will be automatically applied to nodes of a given level in the hierarchy.
      • Finding the wood within all those branches: Searching and filtering allows the user to find just the node that they are looking for.
        • Rummaging through the leaves: Free text searching supports the interrogation of the entire outline structure, or even allows the user to search across multiple outlines at the same time.
        • Make your own categorisation: keyword-based filtering supports the ad-hoc grouping of a disparate set of nodes using 'tags', no matter where they are located within the outline's structure.
      • Data mobility: the ability to import and export an outline's structure in a range of formats, typically maintaining the inherent 'tree' structure, such as through the use of XML based formats e.g. OPML
    • Thoughts on outliners
      • On the history of Outline Processors
        • Dave Winer discusses the genesis of modern outliners as he made the shift from hierarchical program editors, to applications for organising and representing information in general (1988).
        • Ted Goranson discusses a number of early outliners (2004)
      • On the role of outliners in the creative process
        • Jonathan Price highlights the utility of outliners as part of the creative writing process (1997), in particular their support for the iterative revision of ideas. He argues that they provide the user with a set of tools that encourages deeper explorations of the subjects covered by the outline, whilst enabling them to better articulate their understanding of those subjects. Further, when used collaboratively, such as in a classroom setting, he suggests that they can also support the social construction of knowledge, as a consensus can be seen to emerge from the outline's structure. There qualities are achieved because outliners focus on the process of writing, rather than its product, through a cyclic process of research, [re]organisation, and [re]writing.
      • On the hierarchical tree structure of outlines
        • Some authors have argued that the most appealing property of Outline Processors - their nested hierarchical structure - is also a constraint, one which leads the user to think that this is how a set of information is actually interrelated.
        • Christopher Alexander's 1965 essay arguing that it is human nature to try to order information in a tree-like structure - in this case conceptualising the design of new urban areas - but that the real world is better represented by a semi-lattice of interconnecting nodes (of which hierarchical trees are just one example).
          Known for his detailed analyses of the architectural design process, here Alexander attempts to juxtapose the structure of those cities that have grown organically with those that have been intentionally designed on the Architect's drawing board, and in particular how this can lead to urban zones that lack any sense of 'the patina of life'. He argues that this uniformity is a product of our tendency to try and give order to complex sets of information - in order to make them more palatable - even in those circumstances where their complexity may be the very foundation of their value. To achieve this he begins by classifying the two extremes of a continuum of _structured sets of information_ (information that can be grouped together for some reason): from _strict hierarchical trees_ (where each _unit of information_ can only be linked in a hierarchical nested fashion), through to _open semi-lattices_ (where each unit of information can be linked as overlapping collections). In particular, he notes how the use of nested tree structures vastly reduces the potential interconnections that can be made between the members of an information set, and is therefore a natural tool for a human aiming to reduce its complexity. Whilst the essay is focused in the role of the architect in designing urban spaces, Alexander's thesis can also be applied to the management of information in general. In particular, the two extremes of his continuum provide a useful analogy for the design of information management tools and the functionality that they offer the user to structure the information that they contain, such as can be achieved through the strict hierarchical tree of an outline processor, or the semi-lattice approach taken by open hyper-linked systems, such as the World Wide Web. As argued by Alexander, the human desire to give information a nested tree-like structure is a very natural one - being a product of the ways in which our brains try to reduce complexity - and speaks to the reasons why the popularity of outliners has persisted as the technological landscape continues to shift. However, as Alexander notes, there is a cost to enforcing this tree-like structure, and so system designers must consider how the user might be supported in breaking out of this structure when a looser graph of interconnection is required. How then might the pattern for Outline Processors be expanded to take account of this semi-lattice of interrelations found in complex information sets? Approaches include the introduction of tagging or labeling where, in addition to the strict parent-child relationship, each node can be related to any other through an open categorisation system which allows sets of nodes to be displayed together, no matter where they were originally located in the originating tree. Another alternative is to allow nodes to be directly related to one-another, or even to provide functionality to allow each node to be located under multiple parents at the same time.
          • Following a reading of Alexander's essay Clay Sharkey argues that hierarchical tree structures force information to be interconnected at too coarse a scale (2004), preventing the user from surfacing the subtleties of the lattice of relationships that exist within a given corpus.
          • Julian Bond argues that the strict hierarchical nature of outliners forces the user to structure their information hierarchically, even though it may be less structured in reality (2004). Instead, he suggests that hierarchies are just a special case of an information 'mesh', where each piece of information can be related to any other, such as can be achieved in a tag based system.
        • James LaRue argues that outliners focus on editing the underlying structure of ideas, not just words, suggesting that they should be thought of as 'textbases' (2001).
          • James LaRue looks back on the feature rich KAMAS outliner, produced in the 1980s, and what this means for modern outliners.
      • The design of outliners
        • John Buckman examines a range of outliners available on the Windows platform (2004)
        • Scott Rosenberg provides a brief overview of the state of outliners (2006)
          2006
      • Academic Research into outliners and outlining
    • How to outline
      • The basics of outlining
        • Make a wide ranging list of potential topic areas;
        • Enrich each topic area by adding rough notes and comments;
        • Begin re-organising the list of topics, splitting those that are too large to tackle in one go, merging those that are too similar to stand alone, and demoting those that should be sub-topics;
        • Use clear language to justify a topic's location within the outline's hierarchy, ensuring that topics of a similar 'weight' appear at the same level in the structure;
        • Begin transforming topics, first into individual sentences, then into paragraphs, and then whole sections;
      • The role of outlining for the writer
        • Marina Brito suggests that you should create a complete outline up-front, which will make the writing process easier.
        • David Sparks describes how he uses outlining to turn ideas into structured writing
      • Collaborative outlining
        • Jonathan Price on his process for collaborating on the writing of books using an outliner: 'We were testing out an idea to see how far we could take writing toward the improvisatory collaboration of jazz'
          • 'During the first few months, the majority of our time was spent sitting together looking at the computer monitor, swapping the keyboard as one, then the other, got an idea. We argued about sequence, interpretation, emphasis, hierarchy, phrasing, and process until we reached agreement (not just acquiescence). We took that outline well past the initial document plan, so we could accommodate new understandings, new features, new marketing emphases. We also drove the outline down to the level of steps in procedures and explanations of individual commands. We were, in effect, researching and writing as we outlined.'
          • 'We postponed doing any solo writing until more than half way through the project, because we wanted to keep our structure open, accurate, and up to date. We then took individual chapters home and fleshed them out. But unlike our experiences with similar writing, we now knew the subject inside out, and because we had really understood and agreed to the structure, we had almost no structural rethinking, reconsidering, or regrets to work through. The remaining writing went incredibly fast.'
          • 'When we got to the second and final drafts, we discovered that unlike every solo or team project I have witnessed in the computer industry, the structure held up under the scrutiny of two dozen reviewers; we had no last-minute structural changes to make, and so, even during the last week before production, we were able to knock off by midnight.'
    • Example Outliner Processors
      • Desktop outiners
        • Available
          • BrainStorm (Windows)
          • ConnectedText (Windows)
          • FoldingText (Mac)
          • GoldenSection Notes (Windows)
          • Inspiration (Mac/Windows)
            • http://welcometosherwood.wordpress.com/2012/07/21/onenote-smack-down-ii-inspiration/
          • MindRaider (Linux/Windows)
          • Natara Bonsai (Windows/Windows Mobile)
            • "OneNote Smack Down III — Bonsai":http://welcometosherwood.wordpress.com/2012/07/24/onenote-smack-down-iii-bonsai/
          • Notliner (Windows)
            • http://welcometosherwood.wordpress.com/2011/03/16/a-great-outliner-for-windows/
          • OmniOutliner (Mac/iOS)
            • http://downloads.omnigroup.com/software/MacOSX/Manuals/OmniOutliner-3.0-Manual.pdf
          • Opal (Mac)
          • OPML Editor (Mac/Windows)
          • Tree (Mac)
          • Ultra Recall (Windows)
          • UV Outliner (Windows)
            • http://welcometosherwood.wordpress.com/2012/07/20/onenote-smack-down-i-uv-outliner/
        • Deprecated
          • High Files (Unix, 1970s)
          • VisiText (Apple II, 1980)
          • Living Bulletin Board System (LBBS) (Apple II, early 1980s)
            • See "Branch":http://branch.com/ for a modern implementation of LBBS.
          • ThinkTank (commercial implementation of LBBS) (Apple II/Macintosh/DOS, 1980s)


          • MORE 1.1 (Apple System 7.5., 1980s)


            Along with standard outlining functionality MORE supported the production of presentation slides based upon the outline's structure:



            It also supported the production of graphs (a 'tree chart'), although it's not clear if these were a re-presentation of the outline's structure:



            • "MORE 3.0":http://outliners.scripting.com/more30.html
            • "MORE 3.1. review":http://tidbits.com/static/html/TidBITS-198.html#lnk5
          • Acta (Mac, 1986)
          • Ecco Pro (Windows)
            • http://www.wordyard.com/2006/07/
              "All of which may explain why I still love Ecco Pro so much. For one thing, Ecco doesn’t force you to follow the outline structure rigidly; you can drag nodes pretty much anywhere you want. Even more important, each Ecco outline can also be fitted with “columns” — really, versatile tags or categories (they can be free text or checkbox or dropdown or date) that provide exactly the sort of cross-meshing or semi-latticing that Bond rightly reminds us we need. You get the best of two worlds — outlining structure and free-form mesh-i-ness. And it’s very easy to adapt to the David Allen “Getting Things Done” method for those who’ve been bitten by that bug."
          • Shadow Plan (Mac/Linux/Windows/Windows Mobile)
          • Tkoutline (Linux/Windows)
          • GrandView (DOS)


            • http://welcometosherwood.wordpress.com/2009/10/10/grandview/
          • KAMAS (Knowledge and Mind Amplification System) (DOS, 1980s)
          • PC-Outline (DOS)
          • Process (Mac)

            Review of process



      • Online outliners
        • Checkvist
          • http://checkvist.tumblr.com/
        • Dynamic List
        • HTML 5 Outliner (for the automatic generation of a web page outline based upon its heading structure)
        • Knowcase
        • Little Outliner/Fargo
        • LooseStitch
        • Lucid Outliner
        • Thesis builder
        • Thinklinkr
        • Deprecated online outliners
          • SproutLiner
          • Think Fold
          • Treedolist
          • WebOutliner
      • Mobile outliners
        • Outline Pro
      • Applications with outliner-like functionality
        • Personal Information Managers
          Personal Information Managers often have outliner-like functionality as one of their features.
          • Chandler
          • Borland Sidekick (DOS, 1983)
            • http://en.wikipedia.org/wiki/SideKick
          • Circus Ponies
          • Curio
          • Microsoft OneNote
            • http://welcometosherwood.wordpress.com/2012/07/19/announcing-the-onenote-smack-down/
          • The Brain (Mac/Windows/Linux)
          • Tinderbox










          • VoodoPad
          • Yojimbo
        • Task managers

          Some task managers support the creation of nested lists.

          • Action Manager
          • Cheddar
          • FoldingText
          • OmniFocus

            OmniFocus 2

          • Taskk
          • Todoist
          • Workflowy
          • Wunderlist