First post---productivity

I'll make this brief, since it's late. I was talking a little while ago with my friend Mike about a topic which, just in the last few weeks, has taken on an importance for me which for some reason it never had before. The topic was productivity. I was interested in finding the best possible life-organizing software for making me into a productive person, but he was happy to tell me some things he'd read about the theory of productivity generally. In his few brief comments, the theory grabbed me, as Theory is wont to do, but I recognize that I daren't (for the sake of productivity!) make this into yet another of my intellectual projects quite yet.

However, I'll make it into a very limited, very practical project, with a clearly-defined near term. In light of that, consider the absurd prospect that I intend on doing, myself, a mockup (in some easy baby language) of more or less what I think I need in a productivity program. Someone will generously interrupt me (by, please, leaving a comment!) by pointing out an existing piece of software which does more or less exactly what I want and more. I am quite the naif in this area. In the meantime, the program I will put together should have the following capabilities:

• A dependency hierarchy for tasks and subtasks, which perhaps shall be multipurposed into a classification of tasks. More complex structures than hierarchy may emerge as I build.
• A good method of displaying and interacting with this structure visually. Colours, icons, blinking, etc. can represent priority. In particular, it should be editable in a stream-of-consciousness manner, much like I'm doing now, the difference being the superior structures. It should feel like effortless note-taking.
• Prioritization on many axes, or rather along paths of the data structure. First of all, however priority is set, in line with something Mike said it should at the very least reflect separate notions of importance and urgency. These parameters, possibly together with due dates and other data, create a time-profile of the priority of an item. Second, these time profiles are actually time-and-space profiles: it should be possible (even typical) for this data to be relational in the sense of the underlying structure. This task is very urgent and somewhat important to that goal, for example. Transitivity of priorities will, neccessarily, be highly nonlinear.
• This prioritization system, the core of the program, should lend itself naturally to an overall priority measure which causes the representation of the data structure to fold and unfold, or alerts to be sent or not sent, etc. It should easy to send signals which intelligently affect these processes, both directly (e.g. by unfolding a topic or making a query) and indirectly (e.g. by indicating my readiness to be interrupted by different categories of things). To say more:
• Several (at least two) somewhat separate, mutually agile reference frames. For example, it should be possible, if my mood (reflected in some structure) changes, for the relative priority of different tasks to change accordingly. In fact, on the assumption that I quickly get bored and am not good at working singlemindedly on monolithic tasks, a major goal of this program should be to allow me to work opportunistically, i.e. if I don't want to work on its first suggestion, it gives me another.
• Obviously, an interaction with the rest of my computer is ideal. At the very least, nodes should have an activation command which opens a working application. But to the greatest extent possible, this productivity program should be interlaced down into the applications themselves. I.e. below a certain level the relational structures should be reflected somehow in the "working file," either through location tags in a text file, or through some other means in other contexts. Getting back to the ease-of-use point earlier, it might be so effortless that it feels like I'm writing or editing within the productivity hierarchy.
• A back-reaction whereby it should be easy (e.g. selected text and a context menu a la Firefox's search feature) for me to put tasks I'm working on in an application into the productivity program. Here it becomes clear again why it is useful for the productivity program to be interlaced into the application, so that context in the application can be used for appropriately placing and prioritizing things.
• Effective import and export, on-the-fly script and database parsing. In fact, for my program to draw some of its data back automatically from the working apps or other databases somehow would be a bit of a holy grail.
• A tool that lets me profile my own effectiveness at getting my tasks done.
• A tool that lets me profile the program's effectiveness at helping me.
• Holistic and/or statistical methods of guessing priorities. (I.e. effects too clever for my discrete data structures.)
• Efficiencies and coarse-graining and forgetfulness all over the place, agile data structures to facilitate this.
• Can we get some Web 2.0 up in this shit?