notes-organization-organizEtdDesign

Design todos

• todo.txt "priority" letters are also the "priority" here. They mean:
• A,B: sub-today
• C: today, definite (i guess that means deadline and scheduled)
• D: today, mb
• E: next 4 days
• F: flagged
• G: week
• H: fortnight/context/anytime (should soon go here?)
• J: soon/month/context/anytime (should later go here? what about todo, does that go here, or below? i'm thinking below -- todo vs idea is maybe too complex of a concept to be handled by a single-dimensional linear system, given that we also have to handle importances within IDEA and the importance of an IDEA could be greater than the importance of a todo)
• K,L,M,N,O: high importance project priority/importances 2 thru -2
• P,Q,R,S,T: normal importance project priority/importances 2 thru -2
• U,V,W,X,Y: low importance project priority/importances 2 thru -2
• Z: doesn't belong on this list
• view by simple task category. Not quite the same as view by era because schedule and deadline are included
• there is another priority, etdPriority, which can range from approximately 0 to 65535. This is used to represent an ordering (less than total, more than partial?) on lists of child tasks under a given parent node.
• view by era, pri, imp; simpleTask pri
• where we currently have MUTE in views, add deferred and (sometimes) scheduled
• mb have a key to flip between combined and un-combined views, and to flip between superagenda-group-by-outline vs superagenda-group-by-category. And mb a key to flip between importance filtering or not
• make a custom sorter that (a) sorts LOW below everything, then IMP above everything (note: this makes LOW take priority over IMP, as desired) (b) sorts by era? (c) sorts by importance? (d) sorts non-deadlines after deadlines
• if era is a rough scheduled, then perhaps we should constrain the choice of era by any scheduled as well as any deadline
• some views:
• planning: a view combining some of deep planning (but not IDEA), and needsAttention but not actionable, with actionable (both ready and WIP) and agenda, to facilitate selecting tasks to do, when, while seeing how busy you will be at upcoming times
• how is this diff from 'tracking' view?
• overload: ? only those things that you most need to know right now
• radar? upcoming?
• "anytime" view
• per-project overview
• per-project complete task list (how does the restriction work again?)
• https://orgmode.org/manual/Agenda-Dispatcher.html https://orgmode.org/manual/Agenda-Files.html: > or >> , org-agenda-set-restriction-lock org-agenda-remove-restriction-lock, org-speedbar-set-agenda-restriction
• all tasks, in importance sections, sorted, with WAIT/DELEG/MUTE in its own subsection
• look at my old views
• figure out what we are doing with whenEra, and with priorities
• user supplied date upon which a task becomes urgent. Does org mode support date typed properties? Maybe we can also do reminders this way
• read organizOntologies.txt organizJournal

also: check out https://develop.spacemacs.org/layers/+emacs/org/README.html#org-agenda-transient-state and also the leader key stuff at the top of https://develop.spacemacs.org/layers/+emacs/org/README.html#key-bindings-1 which i seem to have made unavailable somehow in my setup because SPC is bound to org-agenda-show-and-scroll-up and BACKSPACE to org-agenda-show-scroll-down and check out https://orgmode.org/manual/Agenda-Commands.html

• goal: "Not Missing Things" (not falling thru the cracks); or "keeping track"

list of buckets giving reasons to especially care about a task

place tasks that you especially need to remember (important or urgent or soon)) into a small number of buckets, maybe 12. Buckets are things like 'important and urgent'; they represent the reason that you need to especially remember this task. Whenever you encounter a task that you are afraid to delete from its original location (eg email) and throw into the task manager, maybe you need to add a bucket to this list.

Buckets so far:

• important
• urgent
• soon
• must
• quick (but not merely quick; higher priority than some other quick things)

and examples:

• email notifying you that a 1099 was issued and that you need to download it
• email that tells you something optional that you can do without negative consequences, that if you did it would make a small but not totally insignificant amount of money
• email that is not important or necessary but will be quick to reply to
• email reminding you of something that you really want to read, even though it is neither urgent nor important and demands no action of you
• email reminding you of something that you want to add to a list, eg:
• email reminding you of something that you dont necessesarily want to read, but that you want to at least add to a to-read list
• email reminding you of something that you want to say to someone else

Feature summary list

• defer dates, due dates, reminders
• readable plaintext exports designed for collaborating with others (so that you can eg filter and then present a task list to a contractor, yet maintain that list from the todo program, rather than making it a separate text file)
• recurring 'chores'. These need to bubble up automatically.
• plaintext source of truth
• delegation
• reviews
• hierarchy: category / task
• projects have an importance as well as tasks, and task importance is interpreted relative to the project: you can mark something as 'important' within a side project, without that making it show up as important in global views of important tasks
• reminders
• usable on mobile (possibly via web app)
• task/project templates
• tags
• tag hierarchy, especially for task status tags
• Kanban based on tags, which understands the hierarchy
• task dependencies
• foss
• ordered lists of items
• Maybe in org mode should have a small number of task templates : Pre-shower , Little thing around the house , todo today, To say to a certain person , etc Pre-shower razor , preShower soap

Non-standard task attributes

• when by era
• milestone
• dependencies
• local/global importances?
• reminders?
• numerical importance
• resolution (or just update/comment?)

Eras of time (timeEra)

Time eras are represented as integers using the following enumeration/convention:

1=today 2=tomorrow 3=next_few_days 4=week 5=next_few_weeks 6=month 7=quarter 8=year 9=someday 0=nil. In the UI the "0" key is used to assign this.

A floating point number in between two eras is treated as falling in the next higher era (eg 1.5 is in the 'tomorrow' era)

Most eras are subsets of each other: (today or tomorrow) \subseteq few_days \subseteq week \subseteq few_weeks \subseteq month \subseteq quarter \subseteq year \subseteq forever

taskType?

0=nil/ordinary 1=tosay 2=todg 3=chore 4=quick/anytime 5=errand 6=call/mtng 7=physical 8=atcomputer 9=meta

Questions

Questions about delegation

• should we have a 'requested' status that is after TODG?

Questions about priorites

• whence priorities?
• are priorities really just for ordering, or are they importances too?
• do we preserve my simpletask priority convention (e.g. C is "today, must")?

Questions about WHEN/eras

• how is WHEN used?
• are both important and urgencies by era? What about flags? Is a by-era flag used to mark something for an era overview?
• should we have era overviews? if so, how do they work? Are tasks auto-selected into the overview by importance/urgency, and/or are they manually selected into the overview with a flag?
• the value of urgency could be an era, the era in which the task becomes urgent?
• how to do custom when eras?
• are flags per-era?
• should whenTime and whenSeq be one field with two alternate enum values?
• for 'anytime', should whenTime be nil?
• if you have stuff like when =month how do you know when to advance that to week? Manual review? Actual dates are much better in that regard.

Questions about other planning attributes

• should we have a MUST?

Questions about statuses

• PLAN?
• task types/contexts such as call meet errand J/say K/quick/anytime/local?

Questions about implementation

• how to do reminders? probably will just use SCHEDULED altho that's annoying
• can you build an agenda view that filters by date on a custom date property?

Questions misc

• task field for self-action versus context dependent action such as talking to someone?
• mb want a way to categorize 'someday' ('zzz' in my lingo) stuff under 'projects' that represent timescales, e.g. "soonish", "this year"
• i already have primary/later/zzz, but i find i don't use them enuf, why not?

Statuses

ok, i'm a little lost there. What do i need the statuses to do, and what was wrong with the way i was doing them before? what do i need them to do:

• defining agenda views
• defining kanban
• sorting/prioritizing
• helping the user remember / track the statuses

what was wrong:

• too many statuses before meant:
• unwieldy ORs in agenda view defns
• takes too long to cycle through in the UI
• since kanban module didn't support ORs, couldn't fit all the necessary columns
• WAIT should have been ortho with completion, but wasn't
• DELEGATE (DG) should have been ortho with completion, but wasn't
• what else? i should read thru the rest of my old notes..
• this formalism doesn't represent different negative CLOSE resolutions by substates. Conceptually, an alternative representation would be for CANCEL to have substates representing different cancellation reasons. However, it may be better to make that an attribute, rather than cluttering the mental model with these extra states.
• our state naming convention is that a noun phrase state name describes the type of thing that the task (or the representation of the task within the todo system) is, whereas a verb describes the thing which is done in that state and which is completed (and in the past tense) to something that has left that state. For example:
• "Work in progress" is a noun phrase describing the task
• CHECK is a verb. When the CHECK state is occupied, a CHECKING activity (process) is taking place, and when the CHECK state exits successfully, the task can be said to have been CHECKED.
• the reason that the DELEG state is not named DEL is because the name DEL is often used in mathematics for the vector differential operator, and I am not currently aware of any meaningful connection between the DELEG state and that operator.

one design principal is to minimize the number of things in various stages of the system. This is the same principal as:

• putting things into a todo system to get it out of your head; the same principal applies to get things out of the todo system's head, both because it is sort of like a cognitive system itself, and because you are going to end up reviewing these things so it will take up your actual attention. You review the list of tasks in some statuses (eg TRACK) more frequently than others (eg IDEA), so it's also profitable to keep as many things as possible in the less-frequently-reviewed statuses (eg IDEA) and out of the more-frequently-reviewed statuses (eg READY)
• the kanban principle of 'minimizing inventory', adapted to the task management domain
• not precisely the same but "the sanctioned action is to cut". This is more of a design idea though. But one of the motivations of that design idea is similar (keep things simple to think about)

for each state, the design justification: NEW: partially formed tasks need to be marked as such, because the propositions 'declared' by the states of some of their fields may be incorrect; one consequence of this is that they need to be kept out of the other states otherwise they may erroneously appear overly highlighted in various views IDEA: keep things out of TRACK ROAPMAP: keep things out of READY SOON: trigger things dependent on this being in SOON (eg tasks involved in getting-ready-for the task in SOON) -- i feel like something that needs to trigger dependencies should be an actual state, so that we don't need to include the concept of tags in our model of dependencies (but we can include statuses); except for the need to trigger dependencies, this would just be a tag, a substate of ROADMAP READY: this is sort of the primal TODO; some superset of this is needed to fulfill the feature requirement of "look at the system and get a list of things i should consider doing now" (especially when refined by the 'actionable' predicate); by keeping ROADMAP (and SOON) out of this, we reduce the number of items shown in here DO: we can minimize the number of tasks in TRACK by prioritizing finishing things that we have already started (like DO) over things we haven't (like READY) note: is this really true though? does prioritizing a long task in DO over a short task in READY help this? i would think not really... CHECK: same justification as DO; by prioritizing these over DO, we can minimize the number of tasks in TRACK FINAL: same justification as DO and CHECK WAIT: keep tasks from appearing in non-review views of TRACK (needsYou) when we can't/won't do anything about them DELEG: keep tasks from appearing in non-review views of TRACK (needsYou) when we can't/won't do anything about them. This is different from WAIT in terms of task completion status, because here the task is not actually stopped. BOOKED: keep tasks from appearing in non-review views of TRACK (needsYou) when we can't/won't do anything about them. This is different from WAIT in terms of task completion status, because here the task is not actually stopped. Why is it not just a tag? Because it applies to both SOON and ROADMAP HOLD: keep things out of TRACK and out of IDEA and out of OPEN CUT, DONE: to keep things out of the system, we need at least one terminal state, it's convenient to indicate whether the task was completed or not

TODO:

Perspectives

• there are sort of 5 functions here, which correspond to 5 places that tasks can be conceptually located.
• reminders to self, which are kind of like my simpletask
• 'tracked' tasks, which are things that you are actually planning to do soon, and which you need to keep 'in view'. Kind of like tasks in a sprint.
• These might be called 'active' tasks (can they be waiting-for or on-hold, though? probably? also, you can have side projects which you work on frequently, so they are perpetually active, but don't need to be tracked. Otoh in a sense you DO want to track things in side projects, you just don't want it to clutter up your view of your more necessary work and home projects). What i am getting at is: these are things that need to take up your attention, even if they are 'on hold' for some reason
• 'later' tasks, which are like sort of like tracked tasks in that you are planning to do them, except they are not 'soon' -- maybe they are dependent on a current task or maybe they can't be or don't need to be started for a few months, etc. Maybe waiting-fors live there? Many of these are things that are going to automatically transform themselves into 'tracked' tasks at some point, and others need to be reviewed so that they can be manually transformed
• someday/maybe tasks -- although someday/maybe is a poor word because some of these are more important/necessary than that. These are kind of like the issue backlog in an issue tracker. The set of these is intended to grow and grow because it has things like 'consider buying a juicer' along with notes on how to choose a juicer, and things like 'learn esperanto', along with important-but-very-not-urgent things like 'write a will'. They should probably have lots of varying importance levels so that you can periodically wade through the most important ones.
• tracker vs issue database vs help desk(responsiveness)
• at an overview level, that can maybe be simplified to 3 categories: reminders (like simpletask); tracked tasks; 'issue tracker'-like task db/archive. Am i missing anything?:
• we haven't talked about time-blocking type stuff at all yet, but mb that's orthogonal?
• what about 'goals' and mb 'themes' and overview-type stuff?
• not everything postponed indefinitely is a 'someday maybe'. For example, i got a notification that my email is taking up 86% of its allowed server space, so i have to clear it out someday. This definitely has to be done, but the timescale is indefinite and more than a month out. So i really dont want to forget about it forever, but i also dont want to do it this month. Similarly to backups.
• Maybe a snooze system is the best way to deal with this?
• Maybe bring back my 'must' tag (more generally, an enum for opt vs should vs must; opt (optional) could also be called mb (maybe))
• again, now we're talking about dealing with the long tail of far future tasks, rather than the near-term tracked tasks
• perhaps tasks can be someday without being maybe, and maybe without being someday
• so again, what other systems call 'anytime' tasks or 'low priority ongoing tasks' might be a separate category
• tiago forte and probably keepproductive seem to think of a 'task manager' as something to plan only what i would call the subset of 'tracked' projects over the next few weeks. Sort of: how i use simpletask (just to remind me what to do each day) + time blocking (that is, planning what to do over the next week or so) + mb a place to remember more distant tasks related to these projects, that might eventually be archived into some other storage if the project is placed aside

need places to put:

• todo.txt list of short-term things to remember to do
• list of current tasks/small projects (stuff like: xmas presents, tax provider for fund, go thru browser tabs, go thru todo list, work on getting permit, work on making task list for sarah, reserve hotel for jan, get vaccine boosters, get new contacts, punch list, send xmas cards)
• longer term planning for big projects (much of the house project stuff would go here)
• long-term ideas for later (someday/maybe but also more important stuff; like "there was something we were going to ask Gary to seal")
• things that are not urgent now but will be later (eg. future taxes)
• recurring tasks like laundry, backups
• sprint/epic-based task management, vs due date-based, vs priority-based, vs ordered queue

different tools for wip project management task backlog personal productivity

(C) backlog vs (workspace?) (see the connection to kanban inventory, wpietri sp big board; limit number of WIP). active vs waiting-on and followups. daily workspace? weekly, monthly too? different tools for: personal workspace (todo list); project management (other ppls tasks eg constructionproj; planning/scheduling far out -- tasks that are 'snoozed' and reappear later; also team task management); backlog (dealing with urgent tasks that will appear later; remembering midpriority should-dos and somedaymaybes and important but not urgents)

functions of organizational systems:

• remembering plans for future ideas
• remembering all sorts of notes and details
• remembering things you have to do
• remembering things you should do or may want to do
• planning and deciding what to do
• planning and deciding what to do and when to do it
• keeping track of when you are busy and when you are free
• motivating yourself

to put another way, systems for:

• capturing todo items, quick notes
• recall and reminders of todo items, quick notes
• knowledge base (notes archive) (pkm -- personal knowledge management, pim -- personal information management, pkb -- personal knowledge base)
• scheduling / calendar, and reminders
• project planning
• task prioritization
• task management / oversight incld. delegation
• project management / oversight

i might divide this into:

• portable capture and recall (simpletask)
• kb (knowledge base/notes archive)
• calendar
• everything else (what i am thinking of using orgmode for)

"someday" todos "anytime" todos

Use cases

some key activities include:

• quickly capturing stuff to 'new' (or might call it 'inbox')
• triaging, categorizing, assigning deadlines, and prioritizing those things
• scheduling stuff: assign 'when' dates; look at how cluttered various time periods are (some sort of 'upcoming'/'radar'/'forecast' view)
• checking in on pending/waiting-for/delegated tasks
• seeing what you are supposed to be doing now
• seeing what is in danger of not being done/what deadlines are coming up -- narrowing some of the above views to only the most important stuff
• looking thru projects and noticing things you forgot about
• reorganizing projects -- adding subheadings, moving stuff around, reordering stuff
• five GTD activites: capture, process, organize, do, review
• looking at things that may need to be done soonish and plucking a few of them into the current epoch
• planning what you will do including seeing how much time you have left and not overcommitting

Need solution for

• soon/should snowplow; often there are tasks that i should do soon (but are not must-dos); so on my simpletask i put them into soon eras (such as (D)). But then, since they are should-dos and not must-dos, they don't get done, and because they are pretty important should-dos, i deprioritize them a little but not too much, and so they end up sitting around (E), (F), (G). I call this a snowplow because it's the way that a snowplow creates these huge piles of snow at the edge of a driveway. soon/should is in contrast to someday/maybe; these are not tasks for the distant future, they are tasks for the short-term, and they are not 'maybes', they are pretty important things. For example, some construction is happening soon, so i should do a better backup of my computer just in case it gets messed up -- this is important enough and urgent enough that i don't want to deprioritize it much, but it's also something that i don't HAVE to do, and i'm pretty busy right now, so chances are i won't get around to it.
• "non important non urgent tasks that actually should be done sometimes soon not just someday maybe"
• i think this highlights the need to have distinction to things you are planning/scheduling to do soon, in the sense that you are pretty committed to doing them, vs things that are sitting on a todo list
• i guess this is when date vs due date, also firmness of when date
• it also highlights the need to distinguish between era and importance. This is another case of urgent but not important. Maybe that's all this is: urgent vs important
• another "obvious" solution is obvious solution is to have a separate set of A through Z priorities for important but not urgent tasks, and maybe another separate set for urgent but not important etc. Is that just floating point importances? Is that just a linear order?
• ok i made the 'flag' field a float to do this
• Are these "anytime" tasks? Or is anytime only if they are also quick?
• when you come back to a project after a long absence (either b/c the project was not urgent, or b/c you were too busy), and you review it, you need the system to surface more important tasks and not let you miss them in a sea of less important tasks and notes. Similarly for tasks that have a deadline far in the future, the system should be able to neglect the whole project for a long time yet still remind you periodically, and still warn you when the deadline approaches. Examples:
• ur accountant says you must do this quick task sometime within the next year
• ur lawyer says you must do this long task sometime within the next year
• important/later snowplow: another type of task that sits on my list at high priority is things which are important and in the midterm. I am worried that if i really just put them at midterm eras i won't look at them anymore, so i put them at soon eras even though i don't plan to do them soon. This one i think can be solved by snoozing/tickler/start date type stuff?
• the "separate set of A through Z priorities" might be helpful here too. Maybe each of the four important/urgent quandrant gets their own A-Z priorities?
• of course actually we'd like this priority to be a float, not an A-Z
• UI-wise could have A-Z and a-z be different somehow. Importance? Something else?
• maybe these A-Z are not priorities, but different levels of 'flagging' something that i need to keep an eye on
• maybe related to/replaced by reminder frequency?
• tracking things that other people were doing/supposed to do
• need better UI than my current orgmode setup (less steps to do common things)
• need a way to deal with what i used to put under (J): stuff to tell ppl. A 'say' file is not good enuf, this stuff has to be more readily accessible.
• how do i reproduce what i used to put under the (J) priority in simpletask? These were things i wanted to say to ppl. I would put the person's name using an @ list.
• say.txt file isn't good enuf, b/c it's not in simpletask
• @ alone without (J) isn't good enuf, b/c i need to have a way to review all of the things i need to say in one place to see if i need to schedule a conversation with someone who i thought i would randomly bump into, but didn't
• within projects want to be able to identify the NEXT task(s)
• at some point weeks away, if a certain person hasn't done something, I should follow up. How do I remind myself of this? This combines two things I have trouble with: tasks far in the future (without a hard deadline, so no calendar event entry), and dependent tasks (altho, is this example really dependent? it's just a waiting-for list item that is far in the future)
• my previous system had too much focus on prioritization of distant items, not enough focus on the near-term
• prioritization system too complicated (too many gradations of importance, etc)
• letting all those more distant items clutter up the common agenda views, making it hard to see all of the near-term/important ones
• need a way to get stuff off my todo.txt when i'm not about to do them in the next few days
• need to deal with when todo.txt gets overloaded
• probably just need efficiency UI to copy things from todo.txt->orgmode and orgmode->todo.txt
• sometimes i dont want to put an important task on my list b/c i am worried it may become crowded out by less important tasks
• sometimes i dont want to put a less important task on my list b/c i am worried it may participate in crowding out more important tasks

Situations and their solutions

• what i didn't have working well in my old todo.txt with semantic meanings was tracking things that other people were doing/supposed to do, and things far removed in time
• things far removed in time: defer dates
• the reason we want finer-grained importances/priorities for someday/maybes is that there are so many of those things that pile up over time that you need a way to sort and look at the most important ones quickly
• I feel like the two things that are stopping me from just jumping back into etd after a long absence are (a) i forget how to use the UI, (b) i just know everything will be cluttered up by a bunch of low priority things which are overdue. The solutions are: (a) more discoverable UI, (b) snooze functionality (to quickly push a tasks's defer date into the future), and views that dont show all of these low priority tasks that are constantly being snoozed
• system needs to be able to accept a bunch of tasks that need to be done far in the future when some other thing gets done that some other person is doing for instance "after stucco tell the General Contractor about all these things that relate to painting", and then to bubble up those tasks at that time
• esp. when you stop using the system for awhile, dont want lower importance recurring chores that you sometimes skip like "reconcile bank balances" to become overdue and clutter up your interface (or if they do, make them easy to dismiss/defer) -- this causes you to avoid using the system at all
• snoozing and importance solve this
• when either (a) ur hair is on fire with a bunch of urgent stuff, or (b) you are heads down in a big long project, you will stop using the system for awhile. Need the system to (1) survive not being used, and later be able to recover and absorb new information (new tasks, completed tasks, etc) with an easy UI, and (2) continue to remember to remind you about important, not-yet-urgent stuff from other projects when you start using it again
• discoverable UI, and importance solves this
• a way to be able to associate important to do items with projects, put them aside for a while, find them again when you come back to the project, or have them pop up if I need a reminder
• projects, listing things by project, importance relative to projects, and various dates solve this
• and what about subdates, eg 'evening'? a lot of ppl use that to indicate personal tasks (as opposed to work) but mb there's a better way to do that (eg areas)? i guess the point there is that when you are looking at your 'today' view the 'evening' stuff is down below, so while ur at work, it isn't bothering u. We can do this by using a floating-point value in whenTime.
• i guess the problem with whenEra-based priority buckets is this: you imagine that the things in the day bucket are being drained out, and when it's empty, some of the things in the week bucket drain into the day bucket, and similarly when the week bucket is empty some of the things in the month bucket drain into the week bucket. But what actually happens is that one or more of the buckets has an average rate of new tasks coming in greater than the average rate of tasks going out, and so accumulates an unbounded number of tasks, and buckets above that one never get drained or even looked at very much.
• i think the solution is to have regular reviews, with frequency proportional to the whenEra, to ensure that if there is a bucket that hasn't drained for awhile, that doesn't prevent the user from remembering the things in the buckets above it. Along with a user practice of trying to drain everything in TRACK.

Approaches

• users will generally 'live' in the (equivalent to orgmode's) 'agenda views'
• the structure of my old todo.txt with semantic meanings for letters worked pretty well (eras for the first letters, and flags, and then K and J for quick and say, respectively). Need better UI to make those ops quicker in orgmode.

stuff to think about

• think about how each of the old letter priorities are represented in the new system
• we probably got dates covered via defer dates, soft deadlines (finish dates), hard deadlines, reminders, actual calendar events. Maybe a waitingfor list and a tickler file could have solved these problems, along with a list of tickle-ed items.
• priority is different from importance;
• mb priority is how soon you are going to work on something (neither importance nor urgency on its own determines this)
• or, mb priority approximates an ordered list

some of my immediate use cases include:

• need to make a todo list for the Oot project
• need to make pld (programming language design; and also a little plt, programming language theory) learning todo list within the Oot project
• todos for this project
• house task list
• house task lists present a unique opportunity for computerization because it should be sorted by both room and trade for example guest bedroom, electric

other ppl keep it pretty simple. Eg some of them only have two gradations of importance (normal and high), some work mostly out of things 3's inbox or today view, some treat 'today' as meaning 'this week' and only plan for this week, etc. They don't care about status ontologies, they focus on just having a list in each project of tasks they thought of, and then assigning some of those tasks to nearby epochs.

• note simpletask's idea of @lists and +tags (as generalizations of @contexts and +projects; e.g. a waiting-for list can be @waitingfor even tho it's not a context; and you can say "@Call +DavidAllen? regarding +GTD" even tho the two +s are not projects) (although some would make this @Call @DavidAllen? b/c in GTD i think a person is often a context)
• what do i even want my system to look like? how would i do it on paper?
• some task status types are sort of like another form of WHEN enum (e.g. PLANNED/SOON/READY/LATER); in particular, i think this is another form of something similar to the whenSeq enum i described earlier
• yeah, there's some sort of pivot/relationship/homomorphism/transformation between task statuses, and some enums such as the WHEN enum. Maybe it's as simple as: statuses are just another enum, all the 'special' stuff about status is implemented as rules in the profile
• in that case there's a bit of 'computerized ontology' ( https://en.wikipedia.org/wiki/Ontology_(information_science) ) about these profiles, isn't there?
• hmm this leads into the config file format and programming language projects then...
• mb what you want in your config files is not a full programming language, but rather a real type system of some sort (so like that description logics etc research in computerized ontologies; see https://en.wikipedia.org/wiki/Ontology_language#Classification_by_structure_(logic_type) )

idea: since it's easy to go to the beginning or end of text files, use both ends. E.g. prioritized todos at the top, 'brainstorm' todos at the bottom. Or short term at the top, long term at the bottom. Or urgent at the bottom, important at the top. Or active todo at the top, waiting-on at the bottom. Or tasks at the top, notes at the bottom.

• "doublecheck" in Todo list needed to go from review status to completed status

Features

readable plaintext exports

can export only a part/subset

also orgmode exports, todo.txt exports

chores

recurring 'chores'. These need to bubble up automatically.

custom colors

color tasks in various views according to custom filters, e.g. if the project and the task are important, then red, otherwise a different color per project

reviews

Reviews are recurring tasks (chores). Reviews are per-project, and different projects can have different review frequencies. Reviews inherit their project's importance.

Are the reviews in some sort of organiz/meta area, or are they in the project they refer to? I think they should be in the project they refer to. This assists in inheriting the project's importance.

You can also set reviews for Areas.

delegation

is my old system (DG, TOGD, @k, etc) good enuf or should i change it?

custom when types

in addition to time era and seq era, there can be other types of eras

potential features

• sequential vs parallel projects (sequential projects have an implicit dependency between each step)

next actions, stuck projects

Implementation architecture

• plaintext source of truth, but a in-memory db (to make preparation of things like org-mode's agenda views quick, easy, and customizable by end-users writing queries) (do we scan the plaintext from time to time to resync in case another process changed it?)
• i don't see a way to provide a custom function which is called when each candidate agenda item is visited and returns a bool to filter that item. This may make it hard to do some of my views. Should i add this functionality first, or do i not really need it yet? Let's try to proceed without it and see how far we get.
• if this is needed, it may be easier for later anyhow if i just go ahead and create my own agenda views replacement
• they do have a 'is this tag filtered' hook that seems useful tho
• wait i think they DO have this: https://orgmode.org/manual/Special-Agenda-Views.html
• also, if you ever want to mutate a bunch of tasks: https://orgmode.org/manual/Using-the-Mapping-API.html
• org-ql allows you to:
• map over results (so makes it easy to get a list of all categories)
• use nested or's and and's and not's in the query
• https://sachachua.com/blog/2015/08/org-mode-date-arithmetic/

i haven't found a good way to hide empty blocks yet:

• https://www.google.com/search?q=orgmode+agenda+omit+empty+block&client=ubuntu&hs=Dgr&channel=fs&sxsrf=APq-WBsPrauHkxhj2_tlMHkZ_vtUlwiymA%3A1643463116980&ei=zEH1YcyZO8egkPIP6JmR4Ao&ved=0ahUKEwjMr6eaidf1AhVHEEQIHehMBKwQ4dUDCA0&uact=5&oq=orgmode+agenda+omit+empty+block&gs_lcp=Cgdnd3Mtd2l6EAMyBwgjELADECcyBwgAEEcQsAMyBwgAEEcQsAMyBwgAEEcQsAMyBwgAEEcQsAMyBwgAEEcQsAMyBwgAEEcQsAMyBwgAEEcQsAMyBwgAEEcQsANKBAhBGABKBAhGGABQ9wVY4gpgywtoAXACeAGAAe0BiAGlCZIBBTAuMy4zmAEAoAEByAEJwAEB&sclient=gws-wiz
• https://www.reddit.com/r/emacs/comments/jjrk2o/hide_empty_custom_agenda_sections/
• reminders are different from scheduled dates (but could deal with that via 'reminder' tag/properties)
• ideally, upon invoking an agenda view, would compute virtual tags for each potential item using a custom hook, then filter based on those
• if you require task dependencies to be intra-file, then you can use autoincrementing integer IDs for the unique primary key field of tasks (without transactional locking) (alternatives would include (a) transactional locking when assigning the autoincrementing integet ID, (b) UUIDs, which are unwieldy, or (c) requiring the user to specify a unique primary key for any task which is the target of a dependency, which not only places an annoying requirement on the user, but also introduces additional (transaction locking) complexity if that primary key ever needed to be changed (which might discourage the usage of the "ref" field as this unique primary key field)). Permitting only intra file dependencies also allows any set of valid task files to be valid together, a property that would be lost if interfile dependencies were possible because IDs might be unique within a file but not in a set of files, or a foreign key reference may contain an ID that does not exist anywhere in the set of files.
• can you build an agenda view that filters by date on a custom date property?
• i guess you can do 'important only if the project is important too' using tag inheritance; have an IMPORTANTPROJECT tag or something, and require the intersection of that with IMP. But then what about tasks that are not with any project? So maybe do the opposite; (IMP and !LOW)

some links:

https://emacs.stackexchange.com/questions/38014/org-agenda-show-whether-entry-has-text# http://pragmaticemacs.com/emacs/reorder-todo-items-in-your-org-mode-agenda/

https://emacs.stackexchange.com/questions/52488/propertize-org-agenda-overriding-header

https://emacs.stackexchange.com/questions/23824/defining-different-fonts-color-per-file-in-org-agenda

org-ql

• https://orgmode.org/manual/Speed-Keys.html
• is there a way to filter agenda views by a custom Lisp expression? "Custom agenda commands can preset a filter by binding one of the variables org-agenda-tag-filter-preset, org-agenda-category-filter-preset, org-agenda-effort-filter-preset or org-agenda-regexp-filter-preset as an option" -- https://orgmode.org/manual/Filtering_002flimiting-agenda-items.html
• you can filter by regexp

https://www.reddit.com/r/orgmode/comments/iw0web/orgsuperagenda_function_to_group_project_with_its/ summary: https://github.com/alphapapa/org-super-agenda groups stuff. Customize with auto-outline-path or auto-parent or auto-map.

https://github.com/alphapapa/org-super-agenda

https://orgmode.org/worg/doc.html

• can you have custom fields or even computed fields in agenda views? Yes, see org-agenda-prefix-format

"Each item occupies a single line. The line starts with a prefix that contains the category (see Categories) of the item and other important information. You can customize in which column tags are displayed through org-agenda-tags-column. You can also customize the prefix using the option org-agenda-prefix-format. This prefix is followed by a cleaned-up version of the outline headline associated with the item. " -- https://orgmode.org/manual/Presentation-and-Sorting.html

org-agenda-prefix-format to customize what is shown in each agenda line http://doc.endlessparentheses.com/Var/org-agenda-prefix-format.html org-agenda-hide-tags-regexp to not display certain tags org-agenda-remove-tags to hide all tags org-agenda-todo-keyword-format org-agenda-entry-text-exclude-regexps (setq org-agenda-entry-text-mode t) (setq org-agenda-entry-text-maxlines 5) org-agenda-entry-text-exclude-regexps

" (defun gg/entry-text-nix-empty-line () "Delete empty entry text lines in agenda" (goto-char (point-min)) (replace-regexp (concat "^ *" org-agenda-entry-text-leaders " *\n") ""))

(add-hook 'org-agenda-finalize-hook 'gg/entry-text-nix-empty-line) " -- https://emacs.stackexchange.com/questions/59546/getting-rid-of-plain-text-timestamp-entry-in-agenda-export

(http://sidebrain.sourceforge.net/ rec by a commentor in https://emacs.stackexchange.com/questions/51161/create-a-rabbit-hole-task-stack-that-can-be-pushed-popped )

" Try customizing org-agenda-prefix-format. This can be used to tweak how various kinds of items (including TODOs) are displayed in agenda views.

In particular, you can use %l in the todo format to prefix the item with a number of spaces corresponding to its level in the hierarchy." -- https://emacs.stackexchange.com/questions/5900/how-can-i-view-the-hierarchy-of-todo-keywords-in-org-agenda-mode

https://emacs.stackexchange.com/questions/14852/divider-lines-in-org-agenda

https://emacs.stackexchange.com/questions/5472/flexible-org-todo-dependencies

https://emacs.stackexchange.com/questions/tagged/org-agenda

org-agenda-filter-by-regexp https://orgmode.org/worg/doc.html read various hooks, search for org-agenda (so far i got about 25% through; to "org-agenda-list") https://karl-voit.at/2019/11/03/org-projects/ https://willschenk.com/articles/2021/sql_in_org_mode/ https://emacs.stackexchange.com/questions/63031/emacs-org-mode-custom-agenda-view-for-each-project https://emacs.stackexchange.com/questions/46882/custom-agenda-view-in-org-mode-grouping-per-month https://www.reddit.com/r/orgmode/comments/elacvo/orgsuperagenda_add_hierarchy_information_to/ https://orgmode.org/manual/Tag-Hierarchy.html https://orgmode.org/worg/org-glossary.html "Changing a TODO state can also trigger tag changes. See the docstring of the option org-todo-state-tags-triggers for details. " http://doc.norang.ca/org-mode.html https://orgmode.org/manual/index.html

could use CATEGORY to specify parent project

could mb implement my 'ortho' status facets using: https://orgmode.org/manual/Multiple-sets-in-one-file.html and org-todo-state-tags-triggers. That is, the TODO state is sort of a composite task status, and when you switch from one ortho dimension to another, org-todo-state-tags-triggers saves the value of the other one in a tag. The value in doing it this way rather than using separate properties/tags is:

• reuse orgmode's existing UI mechanism for TODO state cycling
• reuse orgmode's existing UI mechanism for TODO state display
• use the information stored in tags for more complex views and filtering

org-fast-tag-selection-include-todo

various things can filter/trigger by level, so it may be good to have a fixed number of levels for areas and maybe for projects. What do we do for an empty subarea? Or do we just make the user make up areas for that? Or is the convention that it's the same name as the parent in that case (this could also be the home of catchall'd tasks that are in a parent area but not in any of its subareas)? Or could the convention be that it's the empty string in that case (would make area::subarea formatting simpler: "area::" for the catchall subarea)?

https://orgmode.org/manual/Stuck-projects.html

can agenda views recognize negation of a tag? Yes; using '!', see https://orgmode.org/manual/Matching-tags-and-properties.html. This could make tags triggered onto todo state change easier; otherwise for each ortho set of tax we would have needed to introduce a default, for instance not NOTDELEGATED

principle: want to be able to infer default ortho properties if they are not given. So maybe untracked should be a tag, and idea

• is there a hook for when any tag or property changes, or only when TODO status changes? Yes, all of them are possible:
• when property changes: org-property-changed-functions (called from org-entry-put)
• when tags change, i think: org-after-tags-change-hook (called from org-set-tags)
• there's a more general org-trigger-hook, but it seems to be only for todo status right now. There's also org-after-todo-state-change-hook, which is run slightly earlier -- both are run from org-todo ("Change the TODO state of an item.")

https://orgmode.org/worg/org-tutorials/org-custom-agenda-commands.html org-agenda-entry-types

http://doc.norang.ca/org-mode.html shows how to define 'projects' as any item with subtasks, and then find stuck projects (projects without a NEXT action): http://doc.norang.ca/org-mode.html section http://doc.norang.ca/org-mode.html#TodoKeywordProjectTaskStates section 14.2 Project definition and finding stuck projects

https://sachachua.com/dotemacs/#org00e0838 has " (defun my-org-agenda-done (&optional arg) "Mark current TODO as done.

(defun my-org-agenda-mark-done-and-add-followup () "Mark the current TODO as done and add another task after it. Creates it at the same level as the previous task, so it's better to use this with to-do items than with projects or headings."

(defun my-org-agenda-new () "Create a new note or task at the current agenda item. Creates it at the same level as the previous task, so it's better to use this with to-do items than with projects or headings." (interactive) (org-agenda-switch-to) (org-capture 0)) ;; New key assignment (define-key org-agenda-mode-map "N" 'my-org-agenda-new) "

UI

UI TODO

main screen: modular query spacebar to edit task (without leaving screen) enter to:

• add new task?
• descend into subtasks (eg if the current item is a project)?
• select item?
• change status?

keys i toggles the IMPORTANCE>=1 seach filter on or off I sets a custom IMPORTANCE threshold

edit task mode: choices of key assignments (are consistent with the idea of / reflect the semantics of) keys in modular agenda view

i toggles the importance of the task between 0 and 1 I sets the importance to a custom number esc goes back to modular query mode

new task mode is just edit task mode

if the user doesn't enter a key for awhile, the key hints popup. ? goes to the key assignment help mode. F1 is like 'less' viewing the plaintext manual.

Some of the function keys switch to various preset queries.

On the sidebar is a few preset queries, and starred items, and a project browser.

keybindings: using cokemak layout, here's what we have to work with: (omitting keys like tab, backspace, enter, home, shift, which cannot easily be typed/shown as a single character):

`1234567890-= qwfpgjluy;[]\ arstdhneio' zxcvbkm,./

the home row is:

arst d h neio '

so the most common stuff should go there. My email keybindings work pretty well:

a,A: todo-, todo r: reply, sort reverse s: low, mbox t: up, first

d: archive (dont delete the message, but dont tag it either, and remove from inbox), save (like archive, but also tags with 'save' h: important toggle, flag toggle

n: down, last e: delete, mark with the 'deleted' tag but don't actually delete (note: i dont use this one much) i: fyi, toread (toread means an important fyi) o: wait, ref

',": ctx, custom edit labels

tab: next-new-then-unread enter: display-message space: display-message

so can i be inspired by those to get some ideas for the etd home row?

in email, the most important (non-motion/command/special) key is delete. What is that for tasks? Maybe importance, or maybe when, or maybe todo status change.

note that most task views (a) group by project (or whatever else the user specifies), and (b) preserve task (and section and note) ordering unless the user specifies something else

predefined enums such as statuses are at most 8 characters, and the UI assumes that custom variants are also at most 8 characters (when setting column lengths, etc)

2D grid to cycle through substates

it will be less annoying if the keyboard hints box at the bottom of the UI is permanent rather than appearing after a few seconds of inactivity

The problem with having too many statuses is that in the UI it's too hard to specify one or to cycle through them. This can be ameliorated by per-project choice of status via "project type". Project type could also select whether when era is time-based or sequence / sprint-based. Also these choices could be made at the level of any item for its sub items rather than at the project level; or alternately, an items "project" is its closest ancestor of type project whether that is a project sub project or sub sub project etc.

some paper planners have an "important dates" page -- this is just part of the overview

LATER in the UI could be a capital W (an extreme form of WAIT, which could be lowercase w; similarly, RELY could be a capital D, an extreme form of delegate; SOON could be a lowercase r, a lesser form of READY, or maybe a capital R, a more extreme version of ROADMAP; and what about BOOKED, is that a more extreme ROADMAP?) in ready view, r could be roadmap, blank could be ready, and R could be next action; alternately, blank could be roadmap, r could be ready, R could be next action

Common symbols

W: firm when w: soft when I: important (importance >=1) i: importance <1

Keyboard keys

• consider using something that corresponds to my email custom keyboard layout
• quick UI to 'snooze' tasks
• / for search
• enter or spacebar to create a new item
• spacebar or enter to edit item
• p for project
• x for select

Displays

• show filtered views that only show one project
• list tasks under project headings in cross-project views

Views (modes)

some modes we have: agenda view/modular query, edit item, help

agenda view

shows one line per item and no empty lines in between

• mutt-like sequence of single letter ortho status indicators (i vs I, etc) in each agenda line

Expanded agenda view

shows three lines instead of one and empty lines in between items?

Timeline view

Calendar view

can be per-project, that is, can see each project's 'Calendar'

Kanban view

• sprint planning for the 'tracked' projects: each project has a kanban with columns like 'ready', 'wip', 'done' (and maybe more). These correspond to statuses. The columns included in the kanban can be customized (per-project?): a column can be added for any status (and recall that we have hierarchical statuses, and recall that statuses are a form of types of tasks, so by creating a task status with two "subtype"s, you can set a kanban column to the parent task status and see all tasks in the project whose status field is set to either the parent status, or either child status) or for any boolean expression on tags (and statuses are a type of tag).

Overview views

you can view all tasks by month; but you can also view the month overview, which is a different thing

an overview of an era (are there other kinds of overviews, not counting the ordinary task views/queries such as all important+urgent or flagged or favorited, etc?) includes those tasks which are marked as overview for this area

What else do era overview screens include (are tasks which are both important/urgent at the level of the era included? What about tasks which are both important/urgent in suberas, eg imp urg tasks (the 'now' era) when viewing the month era)?

the PARA system uses the P->A->R->A not just as types, but as levels of overview-ness

in an era overview you can see which tasks will be urgent in that era

older note:

• should we have different "heights" from which to view time? That is should we have characterization of upcoming month in a way different than the union of everything in all the days of that month? If so, do we have events that appear only at the month level, and do we also have some daily events that are promoted to appear at the month level?

Edit item screen

edit item screen starts in a text box editing the item text but other fields are also displayed and you can tab over to them? Or maybe hit escape and then use standard keys (like d for deadline) to access them. In fact maybe editing starts without editing the text so that you can use those keys

Flags and stars

sIf imp and urg and priority are relative to each project, is there any way for a user to force a task to be marked something like 'important' in the global views, that is, UI views showing tasks from all projects? Yes, there is a "flag" functionality, and flagging is global. There is also a 'star' functionality which is adds a task to a 'favorite' list (which is then shown in various parts of the UI, eg the main sidebar; but 'favorites' have relevance to the data ontology beyond just being a UI element (later: okay what is that relevance? my they show up in overviews?)).

Ref autonumbering

Can automatically put hierarchical autonumbering in the 'ref' field, eg. 1.3.11.4, but then later 'freeze' the existing numbers -- this allows you to eg draft a requirements document to give to a contractor, and then after that document is shared with a contractor, freeze the numbering and use the numbers as perma-IDs.

Queries

Preset query screens

• updated in last week
• newly assigned/requested to me
• newly assigned/requested by me
• waiting-for
• important and urgent
• week view
• month view
• next few days/now view
• new/inbox

show important/urgent tasks in any chosen era

Modular queries

i vs I: I means filter for importance >=1 w vs W: W means filter for firm when

various keys for 'when' in various eras

• some fancy query modules:
• only show the first available item in each project
• show all available items (available = not blocked, deferred, or on hold)
• show all remaining (ie not completed) items
• all

Fully custom queries

Use some sort of query language

allow saving queries

Menu bar

• File
• Edit
• Task
• Search
• Help

Function keys

F1: help F2: F3: F4: F5: F6: F7: F8: F9: F10: F11: F12:

Misc UI notes

• if you dont annotate orgmode items with a task status, they are treated like notes, not todos. But in my tool i think we want things to be todos by default, and notes only if they say NOTE or something like that
• vim-like 'nouns' and 'verbs' such as 'x' for 'task status done'; in some contexts x marks a task as done, in others it queries for done tasks
• want agenda views to show tasks under, and grouped by, their projects (headings), and those in turn under their areas. Also need to be able to easily restrict the view to one area or project.
• (another note saying the same as previous) should be able to list tasks by project, that is, within various lists, display the projects as headings under which go their tasks
• so when looking at a 'when', e.g. 'this week', projects should appear under area headings. But when looking at an area, projects should appear under (usually multiple?) 'when' headings.
• want (not yet active) subtasks ("actions") in agenda to not show by default, but you can expand the main task to show them
• action to easily convert task to project
• should be able to order stuff (put items in an ordered list and have that ordering be remembered)
• want to be able to select many tasks and then assign a due date to many of them at once
• UI must be discoverable, esp things you immediately need after sitting down at system after a long break: how to set dates, how to mark an item as done, etc
• keyboard shortcuts should be the same in docs and in agenda view
• .org document editing shows the (non-task) notes by default a lot of the time, which was too much detail for most purposes. Need to avoid that.
• don't have too many keystrokes to do common things
• don't have too many keystrokes to pluck things into the current epoch (set When date)
• quick capture hotkey
• list of all active projects, including ones under the null area, which should be listed at the top
• easy way to reorder projects
• custom enum sequences; for: electric/hvac/plumbing/etc, additional 'when' types. Can show tasks under section headings of a custom enum in addition to the custom section headings
• discoverability stuff in the UI: keyboard shortcuts screen (?), manual/help (F1), menu bar (under hamburger menu in mobile), status bar, sidebar, tooltips, function keys
• orgmode-like cycle-between-task-statuses can be applied to any enum
• view of list of 'upcoming' events/tasks of a certain tag, by date
• view of manually-made list of 'upcoming' events/tasks (e.g. upcoming trips and visits), by date

UI hard / for later

stuff that is probably hard to do, so dont bother for now

• agenda views should not be slow
• drag UI to put something under something else
• email integration: email to etd and then when you get to the task, it calls up the email.
• calendar integration ('events' live on calendar, 'deadlines' live here but optionally can be copied to calendar)
• multiuser stuff: assignment (or request and accept/reject), comments, mentions
• group access privs: read-only, read and comment, full editing, owner/admin (can add/remove others' permissions)
• groups can be given permissions on projects (as if the team were a member; this permission is then the permission of all members on the team, unless overridden by a specific permission grant)
• ('newly assigned to you' status)
• file attachments

generally, we're going to focus on what we can easily on top of orgmode setup, without too much programming. Mayyybe later we can do more, but don't count on it. It's useful to design the ideal system

Misc notes

• some theoretical advantages of a computerized system over paper: full-text search; easy to move things around; instead of having separate sections where you list tasks with certain characteristics, you can include those characteristics in the task item core data structure and present different views of this database as list of tasks meeting certain criteria (database queries)
• note: blocked-by (state BLOCKED) is like depend-on but with the additional information that blocking is occurring now (that is the dependency is currently unfulfilled)
• maybe the default snooze duration should just be one day?
• for issue tracking: issue trackers are not exactly in scope because you want to keep track of bugs even if you have no plans right now to fix them. But i just want to note somewhere: there's a further distinction between bugs that have been confirmed to be real, and bugs which have not even been confirmed but about which you are agnostic, and bugs which have not been confirmed and which you have examined and you think they are probably not real.
• want hierarchy headings like: upstairs bedroom 1 bathroom

  as typed tags. eg loc::upstairs::bedroom 1::bathroom. Then can display using any specific tag type as the hierarchy for display. This allows you to have eg both loc::upstairs::bedroom 1::bathroom and trade::electrical and to switch between, eg, displaying everything sorted into sections by 'loc' vs displaying everything sorted into sections by 'trade'.
  want to be able to mark some headings as not-for-display (eg "upstairs" is good for grouping, but you don't need it in order to understand the task's title; whereas "fix toilet" might not make sense without "bedroom 1")

• todo.txt with ';;' for newline?
• so we have tags relating to the task (eg the loc, trade examples above), tags relating to the objective task status (eg WIP) or other state, and tags relating to what i personally need to do about it (eg "ask Bob to do this", "ask Alice if she wants us to do this", "i think this is done but ask Eve to doublecheck and tell me if she approves it"). In todo.txt, the first (objective mostly-unchanging attributes of the task) can be # and the second and third with @ (task states).
• "stuck" in addition to "blocked" and "wait" and "dg": "wait" means i personally don't have to do anything right now b/c someone else or something else is doing something. "dg" is like "wait" but specifically b/c it's been delegated to someone else. "blocked" means this is a dependent task waiting for its dependency. "stuck" means there is something wrong and the task requires intervention and/or thought (even though it may have been delegated).

misc journal entries

feb 12

i feel like:

• possibly too many moving parts
• but also i feel like maybe it's good to have a diversity of ways to express things in the domain
• i dont have a clear idea of how i would use sibling ordering vs local importance vs global importance
• i dont feel i've captured the fundamental organization of this domain
• i feel like there are all these ideas for views and i dont know which ones i will/should use
• but alternately i feel i had these vague ideas about view concepts like 'radar' that i haven't captured yet

probably the way forward is just to implement, put my actual todos into the system, and learn by using. But i feel like i could possibly benefit from more conceptualizing, too.

Toreads

• investigate stuff like https://en.wikipedia.org/wiki/Critical_chain_project_management , CPM (critical path management), PERT, Gantt, Three-point estimation, https://en.wikipedia.org/wiki/Resource_leveling , resource-event-agent model, and see if any of these have items that need to be introduced into our ontology
• what are the commonalities between popular todo list software tools?
• look into how stuff like powershell passes around structured data instead of text?
• http://doc.norang.ca/org-mode.html#KeyBindings and maybe the rest of http://doc.norang.ca/org-mode.html
• https://sachachua.com/dotemacs/#org5f9cf48
• (mb) https://www.gnu.org/software/emacs/manual/html_node/todo-mode/index.html
• https://orgmode.org/worg/org-hacks.html
• https://orgmode.org/manual/Agenda-Files.html
• "goal Budget schedule" (an ad i saw on a bus, but interesting list of concepts)

(B) 2022-07-27 "today", "current sprint/cycle" are examples of lists (@) and The UI should support EZ tagging of various items with these lists, as well as some sort of defer/later that easily takes them off these lists

2022-08-26 Etd: another needed task status is "my part is done for now but still needs some followup". For example, with house stuff, frequently I notice something, Tell someone about that, then I have to write it down as something to check on later; or I ask someone a question, get an answer, want to check the question-asking task off my list except that I have to remember to tell Catherine about it and maybe to write down the answer

explanations/justifications

no negative urgency or impact b/c then you can't (easily) multiply them together to get a 'priority'

urgency is capped b/c otherwise everything becomes arbitrarily high priority as you get arbitrarily close to its due date. This isn't unreasonable b/c it's supposedly impossible to accomplish something on time anyways if the time left is less than the time taken to complete.

not doing

unsorted

impact (imp) is a floating-point number ranging from 0 to infinity

urgency (urg) is a computed quantity based on target date (=soft due date), duration, and current date: min(1,duration/(due_date - now)). Urgency is a floating-point number ranging from 0 to 1. can you manually override the computed urgency? should the urgency cap be something above 1? Like, 2?

should impact be importance or impact?

if no target date is provided, then the target date is the due date (=hard due date)

if no target date nor due date are provided, then the urgency is 0

priority (pri) is a computed quantity: impact*urgency is priority the right name for this?

is there some other sort of manually set custom "priority"? or maybe you can manually override the computed priority?

task are also ordered (ranked). The user can reorder things.

there are also eras. Maybe the target date is in eras?

duration is how long the task is expected to take to complete, in days. The default is 1.

dates: due date (deadline/hard deadline), target date (soft deadline), duration, (planned) start date, (planned) end date, unsnooze date, creation date, Last modification date

are imp and urg tags computed based on a threshold, or manual, or computed by default by manually overridable?

2023-06-09 Could have numerical scores for importance and urgency but also have an important and urgent tag that are completely manual (could denote by imp urg or just i u). Could even have a high priority tag that is completely manual (could denote by +). Numerical emergency could be defined as a function of due date and expected time to complete (and current date): urgency equals time to complete divided by time left. 2023-06-09 Could have star and flag and selection. Selection is transient/ temporary and star and flag are also tags. Star is sort of like pinned to favorites and flag is sort of like this task needs attention. 2023-06-09 That isn't quite right though, because in this system, even the most unimportant task would become highest priority shortly before it is due. We kind of want the opposite; for even the most non-urgent task to become the highest priority for very important tasks but for a very unimportant tasks never to become high priority 2023-06-09 That can be achieved if we cap urgency. Which makes sense because an urgency greater than one is supposedly impossible to accomplish because the time to complete is greater than the time left. 2023-06-09 Org UI could press enter (or mb space) on any task to go into the task. That shows the attributes, the description, and the subtasks. Maybe there is another key to expand/ contract the subtask tree (<>). 2023-06-09 Org UI, perhaps have hotkeys to easily change things like importance, urgency, due date, duration in one key (eg inc/Dec/cycle for some of these things) 2023-06-09 Org UI should the default keyboard mapping go by the names of functions or by a convenient position in the keyboard? I feel like maybe the movement commands at least should be by position so maybe everything should be 2023-06-09 Org and two keys to incrementally move the item that the cursor is on above/ below adjacent items

---

'pin' a task to the top of whatever lists it shows up in