Using ConnectedText for project and task management

Here is a copy of a post I just made on the OutlinerSoftware forum, in response to a forum member’s problem about how to deal with a large volume of tasks prompted by emails with attachments:

… since I’m a CT enthusiast, let me describe how CT could be used to deal with the above type of problem (partly also for my own amusement at the end of a long week, but also if anyone else might be interested in this).

This might not satisfy your “quick entry” requirement, as there is a bit of setting up involved, but after a while a lot of it can be automated by using keyboard shortcuts and templates (and even more so with AutoHotkey scripts).

There would be many different ways to do it, but here is the simplest scenario (using either the desktop or USB portable version), and the benefits:

1. create a new CT database (“project”) for managing your work projects.

2. when you get an email with attachments that you need to do something about,

2a) create a new “date and time topic” (a new document with temporal features) in CT and give it a descriptive title (can have up to 256 characters),

2b) select all relevant text in the email,

2c) drag and drop it into the CT topic,

2d) if the attachments are important, save them on the hard drive in a folder, and then drag and drop the files into CT from your file explorer, which would create links to the files (clicking on which would launch them in their respective applications, such as Word, PDF reader etc.).

Benefits so far:

Moving the email and the attachments over into CT will identify them as important (a todo), and they won’t disappear as more emails arrive in the Outlook inbox.

Keeping such tasks in “time and date topics” will automatically order them chronologically, and can be also sorted in reverse chronological order, and viewed as a list in the Topic List pane. They can also be navigated through a Calendar interface.

Links to topics created on the same day will be displayed at the bottom of each “date topic”, as “tasks”.

Having the contents of the email and the links to attachments in the same topic will serve as a mini dashboard for that task. More content and files can be added to it, and it can be linked (using wiki links) to other tasks in the CT database.

It can also be split into smaller, linked topics, as a task grows (which can be visualised as a mind map or outline in the graphical Navigator pane).

It is also possible to open and view multiple topics as floating (repositionable) windows, which helps when you need to refer to other tasks in other topics.

3) In order to identify this task as part of one of your larger projects, add a “Category” label to the topic, denoting the project. This will help filter tasks belonging to the same project, e.g. by ticking that category in the Category pane. Alternatively, a separate CT “project” (database) could be created for each real world project, if we are talking about huge projects. But normally it’s better to work from one database initially.

4) Add a red warning type icon to the topic in the Topic List pane to signify it requires attention. Topics can be filtered according to their icons in the Topic List.

Now, let’s say that you’d want to reorder these tasks according to their priority/urgency, which currently are listed in chronological (or reverse) order. For this, you can create an “outline” file in the Outline Pane (or multiple outline files, one per each project, i.e. category). Then,

5) Drag and drop selected tasks (i.e. “time and date topics”) from the Topic List pane into the Outline pane. This will create new outline items with links to the topics.

The benefits are that you can now quickly reorder the various tasks in a hierarchical tree, and it only takes a click to launch any of the linked topics. The Outline Pane has other useful features such as checkboxes (that cross out the done tasks), icons, hoisting etc.

When a task is done, then you can also change the topic icon from a red warning sign to a green tick. The benefit of using CT and date and time topics is that a permanent record of the task and all its contents and linked files will remain in the database and will be easy to find in the future (through search, or the dates, or other parameters).

This would already work as a basic task management system. The above assumes that you have the Topic List, Category, and Outline panes docked in the CT desktop, so it’s easy to see everything and drag and drop stuff from one to the other.

But CT also has a host of other features that make it possible to make the task management system more sophisticated.

This is a long enough post, so I don’t want to go into the details, but there are commands that one can add to templates that can be automatically inserted when a new topic is being created, and they enable you to add “attributes” or “properties” to each topic easily, e.g. to display a pulldown list to choose whether the task’s importance is “very important, important, medium, low, or none,” or a checkbox that, when ticked, adds the “Done” property.

Other options could include adding start and due dates to a topic (task).

The key benefit of using such attributes/properties is that now you can create a summary page (e.g. the Home page of the wiki database or “project”, that is easy to click on or call up with a hotkey), which will automatically populate and update a table of todos with the dates ordered according to a selected parameter (such as start or due dates or importance), another table for actions that are done but you’re waiting for others (this requires adding a “waiting” property, and the name of the person responsible), and another table with the Completed tasks, just for the record.

Here is a link to a CT forum discussion with some templates and more details on this approach:

http://connectedtext.com/forum/index.php/topic,3139.msg15299.html#msg15299

Using Classic Calendar with ConnectedText

While ConnectedText does come with a built-in calendar that in conjunction with its “date topic” documents and outliners allows one to produce all kinds of sophisticated project plans and carry out date and time-related tasks (see some examples here and here), sometimes you may just want to use a very basic calendar to plan a project over a week or a month in relation to a piece of work that you happen to be using CT for.

This is where Classic Calendar [free] comes in very handy, as it is light, easy to use (it uses plain text), and it can be launched from within CT, so you can always remember to use it.

Classic CalendarTo create an individual instance of Classic Calendar, all you need to do is place a copy of the ClassicCalendar.exe file into your current project folder (for example, if you are writing a book, then you could put it into the folder that holds files associated with that manuscript in your directory, and within that folder it might be best to put it into its own folder called “Classic Calendar,” so its settings files can be preserved there), and then either drag and drop the .exe file from there into a CT outline (to create a shortcut) or place an Application Button into the body of a CT topic, so you can launch it from there by clicking on it.

ConnectedText with Classic CalendarYou can have as many Classic Calendars for different projects as you like, as long as you put them into separate folders.

Latest enhancements to my ConnectedText ‘ecosystem’

Actually I’ve used these tools for some months now, I just haven’t had a chance to mention them on this blog. I use the two in conjunction with each other, so it makes sense to mention them together.

The first tool is a software called TaskSpace. The need arose for this one with the introduction of the floating windows feature in ConnectedText v. 6., which allows you to open an unlimited number of CT ‘topics’ (documents). If you work with a multi-monitor setup (and even if you don’t), there comes a point where you might have several floating windows open, which you would need to move around individually (in my case from one monitor to another), which quickly becomes a hassle. Moreover, floating windows come into focus every time you have the main CT application in focus, meaning that the floating windows would obscure whatever other app window you might want to look at in the other monitor while looking at the main CT window.

TaskSpace solves both of these problems. Firstly, by using the handy CTRL+SHIFT+M combination, you can send individual CT floating windows to a single TaskSpace window, where you can further organise them into rows and columns, and then move them around the various monitors as a single window. It is also possible to create tabs within TaskSpace, so you can add as many CT floating windows to it as you like. Secondly, the paid-for version of TaskSpace also gives you the option to change the behaviour from “always on top” to “normal” etc., which I presume would disconnect the floating windows from the main CT app, making it possible to view them independently (and hide them from view at will). I say “presume” because I’ve never tried that feature. I use a comparable feature that comes with Direct Folders, where you just right-click on the close button of any window (except Chrome, with which it doesn’t work for some reason), and the window changes from “normal” to “always on top” and vice versa.

Here is a screenshot of a TaskSpace window with three CT floating windows docked:

TaskSpace_with_CTThe second tool is a piece of hardware called Boogie Board Sync, which I use almost exclusively with ConnectedText, by creating handwritten notes, syncing them via Bluetooth to my PC, converting them from PDF to .PNG files in PDF-Xchange Editor (which allows you to semi-automate the process by setting up the file names and desired image resolution), and dropping them into CT. Then I use TaskSpace to view these handwritten notes as CT floating windows in one monitor, while working away in CT in the other monitor. I use Boogie Board Sync mainly to capture ideas concerning my main writing project quickly (especially when my PC is not turned on), and then I tick them off in CT eventually, once the work recorded in the BB Sync file has been done.

BB_SyncIf you are a CT user and you are still looking for a Christmas present for yourself, I can highly recommend the BB Sync. But make sure to read the Amazon USA etc. reviews about it to understand its limitations. Many customers seem to have unrealistic expectations about it, and then they complain that BB Sync didn’t meet them. However, if you read carefully what BB Sync offers, and you’re happy with those limitations (such as the inability to recall notes on the device itself – saved or deleted notes need to be synced with the PC to be viewed), then BB Sync can become an invaluable tool for getting handwritten notes into a PC quickly, and into ConnectedText in particular. There are of course many other possible use case scenarios, such as e.g. using BB Sync to write handwritten diary entries and then using the date topics feature in ConnectedText to build a handwritten journal.

ConnectedText v. 6.0.7.25 improves floating window functionality

One of the main innovations of ConnectedText v. 6 was the introduction of floating windows, which allowed the user to view multiple repositionable CT ‘topics’ (documents) while for instance editing another topic in the edit window. Besides other enhancements, today’s update of v. 6.0.7.25 improves the functionality of floating windows in a number of ways. Firstly, you can now launch floating windows from a variety of new locations: by double-clicking on the topic title in the viewer/editor’s header; by ALT-clicking on a bookmark; or by ALT-double-clicking in a Go To dialog window or on a node in the Navigator (CT’s visual browser of topics). The other improvement that stands out for me is the adding of a number of Copy functions to the floating window’s context menu. My favourite is the “Copy as URL,” which allows you to paste links to CT topics into external applications (e.g. WorkFlowy) and then launch them from there.

ConnectedText

Workflows and toolchains

Apparently there is a word for the system that I’ve been constructing out of various software and hardware: it’s called a “toolchain.” Check out the use of toolchains in ethnography here and here. I’m glad to see that there is another researcher for whom ConnectedText works as a replacement for a mainstream QDA software (in this case Atlas.ti).

Academic writing workflow with ConnectedText, Freeplane, and Outline 4D

A large part of the academic writing process has to do with taking notes, collecting quotes, analysing and evaluating them, coming up with your own interpretation, then developing an outline, and finally writing up the material into a draft. I’ve experimented with various set-ups to tackle this process in the past that involved a lot of different pieces of software (see here and here). However, recently I’ve come up with a simplified workflow that ‘only’ requires three pieces of software: ConnectedText, Freeplane, and Outline 4D (aka StoryView).

  1. I import quotes and notes into ConnectedText (CT) as I’ve described elsewhere, using my latest reading notes template.
  2. As I am reviewing the document, I identify key quotes and notes that I would like to consider as material for the draft. When I come across an important or interesting quote or note, I select the text and type CTRL+ALT+/ to activate Manfred Kuehn‘s “copy to new topic with link” AutoHotkey script (see below), which copies the selected text, creates a new CT topic with it, and also inserts a link under the original text to this new topic.
  3. Simultaneously to this process I create an outline for the intended draft using CT’s own Outline tool. Whenever I create a new topic with a quote or note using the process described in point 2, I add a corresponding item to the outline and drag and drop this new topic on it, which creates a hyperlink between the outline item and the selected quote or note. Clicking on the outline item opens the corresponding quote.
  4. I export the CT outline as a Freemind (.mm) file and import it into Freeplane (a mind map application). The CT outline has been thus transformed into a mind map. Nodes with links remain clickable, which means that clicking on a particular Freeplane node with a link opens up the corresponding quote or note in CT. I can add further notes using Freeplane’s own Notes functionality and develop and restructure the outline, if I wish.
  5. When I’m finished with outlining and am ready to begin to write the draft, I tile Freeplane and CT vertically in my second (22in) monitor, so I can look at both the mind map (i.e. my outline) and the corresponding quotes and notes in CT. Effectively Freeplane and CT have been integrated to form a funky “dual-pane” outliner, where the first pane is a mind map, and the second pane is the viewer for the note/quote attached to individual mind map items.
  6. In my main monitor, I fire up Outline 4D (aka StoryView) and start writing my draft, while also using O4D’s outlining functionalities for almost real-time reverse outlining, i.e. as soon as I write a larger chunk of text, I add headings and sub-headings to it to crystalise the final implicit logical structure (outline) of the emerging draft. All the while I’m following and ticking off the branches of the mind map and copying across selected quotes and notes from the associated CT topics.

StoryView

This workflow could of course be further simplified, as you could simply use CT’s Outline pane and its view pane as the dual-pane outliner in steps 4 and 5, altogether leaving out Freeplane. However, the benefit of using Freeplane is that it gives an airier spacial view of the outline and it also has its own inline note capability, which CT’s Outliner doesn’t have.

As for step 6, you could use any old word processor or editor to complete the writing. However, I find that the draft usually develops its own implicit logical structure which won’t be identical to the one in the mind map. To put it differently, there is still abstraction and conceptual development taking place during the writing process and not everything in the mind map will make it into the draft. New ideas may emerge from the draft as well. Hence it’s necessary to engage in reverse outlining to keep track of the emerging logical structure.

I did try to use MS Word 2010 with its navigation pane for this (by using headings), however I found that Outline 4D as a single-pane outliner with inline note capability was better suited to the task of real-time reverse outlining, thanks to its multiple options to collapse different sections or view only headings or only text or a custom-mix of both.

Here is Manfred’s AHK script. If you haven’t used AHK before: 1) download, install and run AutoHotkey_L on your PC; 2) create a new text document in Notepad (or your favourite text editor – I use NoteTab); 3) copy and paste the script below; 4) save the text as e.g. “copy_to_new_topic.ahk” on your desktop; 5) run it by double-clicking its icon; 6) use it by selecting the desired text in CT, typing CTRL+ALT+/ and then naming and saving the new topic.

By the way, you could also just use CT’s own built-in “cut to new topic”  (CTRL+ALT+N) command, which does not require AutoHotkey and which also leaves a link behind in the original topic. However, I prefer to use this “copy to new topic” AHK script because I want to preserve the integrity of the original document (which e.g. could be the full text of an academic article).

;---------------------------
; Copy to new topic         |
;---------------------------

^!/:: ; copy to new topic

clibboard =
Send ^c
InputBox, OutputVar, Topic Title, Enter the title of the new topic:
if ErrorLevel <> 0
{
     MsgBox, You cancelled
     return
}
else
{
     WinActivate, ConnectedText
     SendInput {Right}%A_SPACE%
     SendInput `[`[%OutputVar%`]`]
     SendInput !t
     SendInput %OutputVar%`n
     IfWinActive, Confirmation
           return
     else
           SendInput ^v!e
     return
}
return

Update (24/01/2013)

Here is a visual representation that summarises my academic writing workflow with the associated tools. It should be read in light of my additional comment below (i.e. there are two different types of outlines and sets of evidence represented). I have also included the tools that I use for note-taking (step 1).

academic writing process

Analytical process flow for reading notes in ConnectedText

Currently I’m working on my literature review. Here is my analytical process flow for importing data, analysing it, and outputting information using ConnectedText (CT) and a variety of other tools. This process flow is just a snapshot, it’s not set in stone. It keeps changing as my needs change and as I gradually develop approaches that better suit the creative process of analysis, evaluation and synthesis.

  1. Importing reading notes into CT:
    1. I read and annotate academic articles in PDF form using GoodReader (if the text can be highlighted) or PDF Expert (if the PDF is a scanned image) on an iPad.
    2. Then I email the notes (highlighted text + my comments) and the annotated file to myself.
    3. On the PC I replace the original PDF file with the annotated one, re-link my EndNote reference to it, and copy and paste the highlights and the comments from the email into a new CT topic in my “Readings” project (CT database) under the ==Quotes/Comments== heading in my CT reading notes template.
    4. With printed books (i.e. not e-books) I take notes using a pen and a paper notebook, and when I’m finished, I use Dragon NaturallySpeaking to dictate the selected quotes and my comments into DragonPad, from where I copy and paste them into the CT template as described above.
  2. Analysing and evaluating reading notes in CT:
    1. I use CTRL+H to “search and replace” (also available from Search > Replace) the headings inserted by GoodReader/PDF Expert with either ===Quote: === (for highlighted text) or ====Comments: ==== (for my own comments).
    2. I review the text and extract the essence of the quoted text and comments and add it into the headings, such as ===Quote: cognitive functions are socially acquired===, followed by ====Comment: I agree with this====.
    3. I use yellow colour to highlight particularly important quotes and comments.
  3. Organising conclusions:
    1. If the CT topic is short, I can develop and record my conclusions immediately under the heading =Evaluation=. I summarise my main point in a final couple of sentences under =Verdict=, including them in the attribute [[Verdict:=My concluding sentences go here.]], so that they show up in the Infobox at the top of my CT topic.
    2. If the CT topic is long (i.e. it contains a lot of imported quotes and comments), then I need to use additional tools to organise the annotated headings.
      1. I remove the [[$NOTOC:]] markup from my template, so that the Table of Contents (TOC) becomes visible within the topic.
      2. I highlight the contents of the TOC, right-click, copy, and paste it into a blank Natara Bonsai document. In Bonsai I already have the new document template set up, so that different hierarchical levels appear in different colours, to aid the sorting of information.
      3. Using Bonsai’s outlining functionality, I reorganise the imported contents of the CT TOC into a meaningful hierarchy.
  4. Developing an outline for the draft chapter:
    1. The whole purpose of evaluating reading notes is to come up with my own interpretation, supported with evidence. The next (and parallel) stage is to develop an overall outline for the draft thesis chapter. Depending on the complexity of the material, it may require several tools still:
      1. I keep CT open to be able to view given reading note.
      2. I consolidate material (my main points supported by key quotes) in a final Outline 4D outline (which is a single-pane outliner that can have inline notes, in contrast to Bonsai.)
      3. During this whole process I use an overall VUE concept map to work out relationships between concepts and to develop an argument.
      4. I record the very final overall outline in the form of a Freeplane mind map.
  5. Writing up:
    1. to manage the final writing-up process, I use MLO to record to-dos as they develop.
    2. I do the final writing-up in an Outline 4D document. The advantage of using O4D for this is that it obviates the need for another application to do reverse outlining as the text grows, because it is easy to alter headings for multiple hierarchical levels and toggle them on and off, when you only want to see the text. I find this better than dual-pane alternatives such as Word with Navigation Pane or Scrivener.
    3. To add references, I simply type the reference such as (Smith 2008: 35), so as not to be distracted and disrupted by having to switch to EndNote every time (and it is not compatible with O4D anyway).
    4. I export O4D text to Word.
    5. I replace manual references with EndNote references, to build bibliography.

Here is a graphic just showing the latter stages of my writing-up process flow. I embed these types of process flow graphics in the home page (dashboard) of my reading notes wiki, so that they remind me every time I get stuck. Chances are that in a few days it will be replaced with a modified process flow, as I keep tinkering with it.

writing-up process flow