Submitted by jimspoon on 2022/07/17 11:30

When I'm writing anything, I'm constantly rearranging my sentences or lines.  In Word or a text editor, this means cutting and pasting.  But if I put each sentence or line in an IQ item in an IQ outline, this rearranging becomes very easy.  An IQ item can become a whole document in its own right, consisting of its hierarchy of subitems.  Under that Level 1 "document" item, the Level 2 items could be headings, Level 3 items could be paragraphs, Level 4 items could be sentences.  And then at some point, this item could be printed or exported to a non-IQ format, with the IQ hierarchy being correctly translated into however that hierarchy is represented in that destination format.  Of course when working with such a "document" in IQ, you must be careful to preserve the proper ordering of items in the hierarchy.

A document is a hierarchical ordering of paragraphs and sentences, or lines.  When represented in a linear fashion, e.g. on paper, or its visual representation in a word processor, that hierarchy can only be represented with visual cues such as headings of fonts of different sizes and weights, and grouping and ordering of sentences into paragraphs.  The linear representation has its advantages of course - one need only read straight through from beginning to end, without any need to expand or collapse items.  But this way it might be more difficult to grasp the hierarchical structure of what you're reading, so that you have to turn pages or scroll up and down, consult a table of contents etc. to see how things relate to each other.  In a computer (e.g. IQ) outline the structure is explicit, collapsible, and can be rearranged as needed.    

Another (crazy?) idea - even the output of a computer terminal like CMD, Powershell, or a Linux shell could be presented and browsed as an outline.  Imagine working in your shell, and being able to expand and collapse that output, where the commands entered would be a parent item, and the output from each command would be subitems of that parent (itself perhaps hierarchically arranged).  I bet someone has thought of that. 

Any thoughts on such a use of IQ to compose documents (or even code) in this way?

Comments

Hi Jim,

I'm not sure I grasp what this "crazy" idea is, but for the record:

  1. The Doc pane can expand / collapse sections based on headings
  2. You can export a hierarchy of items + Doc pane content to a single document. If you then paste this into the Doc pane of a single item, you can read this compounded document with expand / collapse capabilities
  3. The Export > Table of Items and Field Values has an option to add expand / collapse hyperlinks which will be functional in any browser

If any of these 3 features is new to you, do not hesitate to ask

HTH !

Pierre_Admin
IQ Designer

  1. The Doc pane documentation is due for a major revision. I'll try to do this in the coming days. In a nutshell, heading styles behave like hyperlinks, click on these will expand / collapse all content up to the next heading of the same level (or higher). There are no expand buttons, simply click on the heading text. Single-click when in Browse mode, Alt+Click when in edit mode
  2. Details here: 2. Export Outlines (Print-ready)
  3. Details here: HTML Export dialog: Table with Columns

Pierre_Admini

 

The problem, I think, lies in the use of text connectors / linking expressions. Say you have a sentence starting with "Nevertheless, ...". This sentence can only really follow one specific sentence, i. e. the one that came before it when it was originally written and outlines reasons against what is said in the "Nevertheless, ..." sentence. To a certain extent, this is also true for fully worded paragraphs.

Hence, in my opinion, outlining is great while gathering and structuring ideas in keywords but once you get to the stage where you have fully formulated sentences, it becomes somewhat less useful as you have to adapt the wording of elements when you move them around.

A very compelling related concept is Literate programming, i. e. turning a program into an annotated piece of text which still retains the ability to be compiled or executed as a program.

General Discussion