I'm looking for a to-do application and I'm having a little trouble finding one that fits my requirements. Hive mind to the rescue!

• Needs to have some sort of task dependency feature
  • I don't really care how it's implemented, but it needs to be able to support more than just a simple sequential dependency. (Being able to support sublists as tasks and having lists support both sequential and parallel completion would be fine, for example.)
• Needs to support a smart list of things that can be done now based on those dependencies
  • That is, I want to be able to see a list that excludes things that depend on other things that haven't been done yet
• Free
• Needs to be usable on a Mac
  • Can be browser-based, native app, whatever, just not a Windows-only app

Any suggestions?

Ones I've looked at so far that (seem to) fail my requirements include:

• Toodledo
• Producteev
• Do.com
• Nirvana
• Wunderlist
• GQueues
• Astrid

If you think that I've made a mistake with one of these, let me know. I may have.

Remember the Milk?

I'm honestly not sure if it does what you're asking for, as I haven't tried it in years, but I didn't see it on your list. The paid version mostly adds mobile support and syncing with Outlook.

No, it doesn't. Here's a list of some more that don't:

• Timegt
• Tasque
• Conqu
• Task Coach
• Todoplus
• New York Minute
• doit.im
• Things
• iProcrastinate
• Task Unifier

However, it looks like Hiveminder might do what I want.

Basecamp?

Edit: I could swear they used to have a free limited version, but I no longer see that option.

After trying to use Hiveminder for a while, I'm having problems. The biggest is that there's no way to see my whole hierarchy of tasks, which makes it really difficult to figure out how to put things in the hierarchy. Add on to that the fact that when adding dependencies, the only way to add one is to already know its UID....

Well, it's just more of a pain than a help.

After using it for a while, though, I've been able to come up with a better way of saying what I want: a tool that will keep a hierarchy of tasks and show me which ones I can work on right now. Hiveminder does that, but it's far too difficult to edit an existing hierarchy.

TDL? I haven't used it in ages, but it worked well for me when I did. I'm not sure how complex your dependencies are, but for my simple needs, the sublists were sufficient. Open source, with fairly straight-forward code (I submitted a patch for a bug), so if it doesn't do what you want yet, it could likely be modified so that it did.

As much as I am a command-line guy, using the command line for this sort of thing is just not working for me. (I also tried TaskWarrior, which has dependencies, and is also command line.) I don't want to constantly have to reference multiple sets of outputs in order to manipulate tasks. I left "mh" behind long ago.

I think that I've found a contender in Tracks. I dismissed it before because the available demo site was running an old version and didn't have the features I needed.

The dependency manipulation "gesture" is backwards from what I'd expect, but I think I'll get used to it.

Well, naturally. It was replaced by "nmh".

I also looked at Midnight Inbox (Classic) again. It actually comes really, really close, but its selection of workable tasks from its hierarchy is maddeningly backwards. Basically, you can have lists embedded within lists, but it presents to you as workable the first (uncompleted) item in each list, regardless of its position in the hierarchy. For example, in this list:

1. Major Task
2. Major Task
   
   1. Subtask
      
      1. Item
         
      2. Item
         

it selects 1, 2.a, and 2.a.i as the workable items, while I want them to be 1, 2.a.i, and 2.a.ii.

FWIW, I'm taking this thread over to my Google+. If anyone is interested, I'll be talking about my experiences there. No reason to bore you guys with my braindumps.

I just got transferred to a new group writing software requirements (what the hell?), please, for the love of all that is holy, bore us with your braindumps.

Yeah, seriously, what's this BBS for anyway?

Fine. Crossposting it is.

I've been thinking a lot about task dependency over the last few days, and while what I initially thought I wanted was subtasks, it isn't. What I really want is task dependencies. After finally finding a few tools that supported subtasks, I found that what I wanted to do with them was really awkward.

The use case for this for me is that you look at a list of tasks and realize that you can't complete one without first completing another. I look at my list of tasks frequently and each time I have to realize that that one task is dependent on another is time wasted. So I would then want to mark that task as dependent on the other task. At that point, that task would be hidden from my list of tasks until its blocking task has been completed, at which point it would reappear in the list of tasks.

A trivial example is:

1. Read "Getting Things Done"
2. Purchase "Getting Things Done"

I obviously can't read it before I purchase it, and I don't want to be reminded to read it until I can actually do so. So I mark task 1 as dependent on task 2 and then my task list looks like:

1. Purchase "Getting Things Done"

When I mark that task as complete, my task list suddenly looks like:

1. Read "Getting Things Done"

It seems like this is doable with sublists, but it's not. Here's an example:

1. Install Apache
2. Install Linux

I can't install Apache before I install Linux. Fair enough. I mark task 1 as dependent on task 2. In the naïve sublist implementation, this looks like:

1. Install Apache
   1. Install Linux

Now I realize that I also want to install MySQL:

1. Install Apache
   1. Install Linux
2. Install MySQL

I can't install MySQL until I install Linux, so I want to mark task 2 as dependent on task 1a. But with a sublist implementation, there's no way for multiple items to depend on a single item. You'd have to have some sort of group item containing both Apache and MySQL that depends on Linux, and then once Linux is completed, for that group item to explode into its constituent items.

1. Install Apache / Install MySQL
   1. Install Linux

And then you get into problems with dependencies in the other direction. Say I now want to install PHP. But I have to install Apache first. But it's now part of a group with MySQL, which PHP doesn't depend on.

It's probably possible to come up with ways to force these scenarios into being represented by sublists, but it gets really awkward really quickly, and then you end up wasting time trying to figure out how to create the structure of your lists instead of doing productive work.

That said, having a more abstract dependency model can end up making things hard to visualize. I think the middle ground is to merely notice these dependencies as they arise in your task list and just mark them then. There's (probably) no reason to delve deep into the planning process for this sort of thing. Notably, making sublists forces you into that mode, assuming that your project gets even remotely complicated.

I think that the real answer is just to recognize that one task depends on another when it occurs and mark that dependency then and forget about it. That way you're not wasting time doing ridiculous planning, but you're also not repeatedly wasting time remembering why you haven't started on that one task in your list yet.

I would love to be have a similar system at work, at the moment it's all done via email resulting in 100s of emails daily, most people mark as unread items not dealt with but it's totally inadequate and the people CCd on the task are just random based on the who the originator thinks should be involved.

I've looked at help desk systems before but they're either too simple/basic, or extremely complex so I'm definitely interested in your experiences too.

Just to get it out of the way, none of the following task management tools seem to support any sort of task hierarchy or dependency at all. Since this is a requirement for me, I'm not even going to bother reviewing them at all. (This is a lie. Jump to the bottom for a couple of very small reviews.)

• Remember The Milk
• Producteev
• Toodledo
• Astrid
• Do.com
• Wunderlist
• Things
• Todoist
• Asana
• Orchestra
• Any.do
• Conqu
• Tasque
• TimeGT
• New York Minute
• HubList
• iProcrastinate (honorable mention for best app name)
• doit.im
• TaskUnifier
• Firetask

Those are vaguely ordered with most well-respected and/or well-known at the top, based on my personal bias.

Again, none of these support any notion of task hierarchies or task dependence that I can find. If you think I'm wrong about any of these, let me know and I'll take another look.

That said, if I didn't have that requirement, I'm pretty sure I'd be using Asana. It looks nice, it works well, there are a huge amount of collaborative features, and I like the unique pricing model. The only thing I can think of that I'd add is native clients, and, honestly, the web app works really well. More than well enough for a Fluid/Prism-type app to seem native. Also, they provide a pretty solid looking API, so native clients should be possible through third parties.

It's also worth pointing out that the very first product that I tried was Producteev, and I've been using it to keep ordered notes on this whole process. I also use Evernote for note-taking, but it doesn't lend itself as well to structure. (Maybe if they fixed their awful editor ….) I think that if I was looking for something very simple, Producteev would be the way I would go.

http://orgmode.org/ of course

Ugh. That would require me using Emacs. Not gonna happen.

I am not sure there's an OSX version but there may be: Microsoft Project.
It's CPM-PERT based, all dependencies should be well dealth with.

Probably I don't understand exactly what you are trying to do... but it seems to me that you could accomplish this using (drumroll, please...) you guessed it: Excel.

Make a list of tasks, say 1-9, more or less in order of importance.

Task 1
Task 2
Task 3
Task 4
Task 5
Task 7
Task 8
Task 9

Now add an index column in front of it, modeled on the Dewey Decimal system:

1.000 Task 1
2.000 Task 2
1.100 Task 3 (Dependent on task 1.000)
3.000 Task 4
1.110 Task 5 (Dependent on task 1.100)
4.000 Task 6
2.100 Task 7 (Dependent on task 2.000)
2.110 Task 8 (Dependent on task 2.100)
5.000 Task 9

Now sort the list by the index:

1.000 Task 1
1.100 Task 3 (Dependent on task 1.000)
1.110 Task 5 (Dependent on task 1.100)
2.000 Task 2
2.100 Task 7 (Dependent on task 2.000)
2.110 Task 8 (Dependent on task 2.100)
3.000 Task 4
4.000 Task 6
5.000 Task 9

The task you want to do next is always at the top of the list. You can have tasks dependent on tasks that are dependent on tasks that are dependent, ad-infinitum, that is if you had a new task that was dependent on task 2.100, you'd add it and index it as 2.110.

When a task is finished, delete it from the list. It isn't real pretty, but you could make it so with a bit of conditional formatting.

Of course, as I said, I probably don't fully understand what you're trying to do. But this is how I'd do it if I weren't retired and not under pressure to do anybody else's tasks. Oh, wait... SWMBO...

tanstaafl.

Hammer.

make. It does dependencies. Or, design a DSL using Ruby and use rake.

Other than completely agreeing with Roger (if someone made a tablet that just did spreadsheets, I can't imagine how excited you'd be to got get one), your system fails one of the basic requirements of task management (which I admittedly didn't state): that it show me all the tasks I can perform right now.


In that list, I can perform tasks 1, 2, 4, 6, and 9, but I have to scan through the whole list of every task in order to discover that.

I came ->this<- close to suggesting make.

Here's the "almost" list of tools that support some sort of task dependencies, but then fail in one manner or another.

---

Nirvana was mentioned by former Producteev users as one of the few tools that supports task dependencies. As it turns out, all it really has is the ability to select whether a project's tasks can be completed in parallel or if they have to be in series. There's no support for arbitrary dependencies, and no support for subtasks. I'm honestly not really sure how that helps. Otherwise it seems pretty nice.

---

Midnight Inbox Classic is a Mac OS X application. It supports task hierarchies, but not arbitrary dependencies. It has a to-do list that shows you the tasks that you can work on right now. That list also shows upcoming tasks ordered at the bottom of the list in a different color, which could be handy for letting them not get completely out of sight. When I first started trying Inbox Classic, I thought it was going to be the one. But then I realized I was confused by how it was selecting what tasks I could perform. I finally realized that it was marking the first task in every list as doable, regardless of the depth of the location of the list.

In my mind, if I have a list that looks like this:

1. Purchase milk
   1. Drive to store
      1. Get driver license
      2. Get car keys

I have to perform steps i and ii in any order, then proceed to step a, then step 1. Inbox Classic told me that I could perform any of steps 1, a, and i; and after I completed i, I could then proceed to step ii.

It's possible that I could reverse my ordering so that this makes sense, but this seems to cause the incompatible dependency problem even earlier, plus it makes the final goal seem insignificant. Somehow I feel like I should be working up a hill, not down it.

---

TodoPlus supports hierarchies, but doesn't seem to have a doable task list. It also only runs on Macs through Mono (an implementation of Microsoft Windows .NET framework), so it looks like a Windows application, and a notably ugly one at that.

---

ActiveInbox is a Firefox and Chrome plugin that deals with your tasks directly within Google Mail. First off, this is a paradigm used by Microsoft Exchange, and it's never worked well there (IMO), so I'm immediately turned off. It also seems to support only hierarchies. To be honest, I was so turned off by everything being an email that I didn't really explore this one in depth. It did not appear to have any sort of task dependency.

---

Google Tasks is the tasks widget available in Google Calendar. It supports hierarchies, and if you check off a parent, all of its children autocomplete. But that's it. It even forgets which children you'd already completed if you accidentally complete a parent task and then uncomplete it. Again, not very useful. (BTW, it wasn't obvious to me how you can subordinate a task in Google Tasks. Simply press tab when a task is highlighted and it moves it in one level.)

---

GQueues is a third-party Google Apps plugin. It supports task hierarchies, but it doesn't appear to have any way to show only the doable tasks. Not really all that useful for me. I might as well just have a list on a piece of paper that I cross off as I go along.

meh given you're linux/commandline then it's 50/50 you were emacs or vi

I think org-mode is about a 95% fit ... I just found this commit message:

"This adds two new tests to `org-agenda-skip-if': 'todo-unblocked and 'nottodo-unblocked. These match like 'todo and 'nottodo, but only on unblocked todo items. This type of test is useful when compiling custom agenda views containing lists of currently actionable todo items. "

All stored in plain marked-up text too - but nm ... such is religion

Only emacs users think they make up 50% of editor usage.

I had to use ed once on a system that didn't have anything else installed. That was an awfully traumatic experience that I never want to repeat.

When I started my CS studies in 1979, they DEC VT100 had just been introduced, but we still had a combination of ADM3a's and DecWriters - so a line editor was the only choice...

Now we're into tools that meet my criteria. The first is Task Coach.

Task Coach supports both folders and arbitrary task dependencies. Filters can be used to hide inactive tasks. It does pretty much everything I want.

However, the user interface is not so good. In order to define dependencies, you have to edit the task in a new window, select the "Prerequisites" tab, and then select the task or tasks that I want it to wait on. To be honest, this is too much work for what I expect to be a primary staple in my workflow.

Also, the UI is built in wxwidgets, which is better than Mono, but not by a lot. Nothing about it makes me want to use it.

On the plus side, it supports basically all desktop operating systems, and they have an app for Apple iOS. Plus they have SyncML syncing built in, so you should be able to sync with a variety of providers.

But I don't think that this is the one for me.

The next tool is Hiveminder.

It also supports task dependency, and, in a nice addition, you can set forward and reverse dependencies. It doesn't require that you go into a special edit mode to assign them, either. And by default, it only shows you the tasks you can complete, which is nice.

But, in order to assign a dependency, you have to enter a task ID. There's no dragging or any other gesture-like selection. And task IDs are short alphanumeric strings, like "3O8XO". Notably, it doesn't even offer a way to autocomplete a task ID based on entering the title or anything like that. You have to know the task ID. Since it hides dependent tasks, the task ID you need may be hidden. But even if it's not, it displays it in hard-to-read light gray.

Also, if you do want to look at all of your tasks, you're forced to use a search. And while you can save searches, that's only a feature of the pay version.

That's just the tip of the iceberg for UI problems, really. Okay, most of them are not problems, but newer apps (albeit without the feature I need) do so much better on this front. They're nice to look at and work with, and Hiveminder is just not. I tried to use it for a day, and it was just really a pain. Everything felt like a struggle.

But the thing that bothers me the most is that the last time that the developers mentioned Hiveminder on their blog, it was 2009, and even that was only the announcement of a third-party iOS tool. I feel like it's basically been abandoned.

Taskwarrior also supports task dependencies. It has a lot of similarities with Hiveminder, in that you have to specify dependencies as task IDs, though it's a little more flexible and less opaque than Hiveminder is. But there's still no gesture support, and that's because Taskwarrior is a command line tool.

I think of myself as being a command line junkie (I'm far more likely to do math by bringing up a shell and running "bc -l" than any other calculator), but I think this is taking it a little too far even for me.

It seems like Taskwarrior has a lot of features and is really solid. It even supports synchronization through a few methods, and it's open (in both the source and API senses) enough that people have gotten a variety of layers working over it, including a web interface. (Which, sadly, I haven't had the time to get working.)

I really like the concept here and I totally support these guys, but, for now, Taskwarrior creates too much overhead for it to be a successful tool for me.

The tool I've settled on, at least for now, is Tracks. I wish that Tracks was hosted somewhere for free, but I'm happy to host it myself. That may be a problem for some of you, though. (Also note that there are some Tracks installations out there to be demoed, but many, if not all, of them are old versions of Tracks. I almost dismissed Tracks because of this.)

Tracks runs as a web application. It allows arbitrary dependencies. It allows you to drag dependent tasks onto the tasks they depend on to assign dependencies, but you can also enter tasks manually into the task description, and it offers autocompleted suggestions based on the beginnings of task descriptions that you type in. It only shows you doable tasks by default.

Honestly, the only things that I would change are that it would be nice to see the ability to also define a task as a being a dependency of another task instead of only marking tasks as being dependent (not that that's much of a hindrance), and an easier and/or better way to see every task than just searching for nothing.

There are also prebuilt packages at http://bitnami.org/stack/tracks for when you're lazy like me and don't feel like mucking about with its dependencies.

It also has a RESTful API for if and when I want to write a tool to interact with it. (Which I will probably do very soon in order to create a reminder app. I get distracted easily.)

Tracks is pretty much the web app I was looking for when I started all of this, and it took me an awfully long time to find it. I hope that this series of posts will help someone else who has similar requirements to mine.

Now, hopefully, I can get some things done.

After having dealt with Tracks for a few days, I still like it, but there are some problems that I'd like to point out.

While you can put notes on tasks, there's really only one note. You can append to it and change it, but it would be nice if you could just add more and more distinct notes.

There is no field for priority. It would be nice if I could mark tasks as low priority so that they would be shuffled to the bottom of my to-do list.

It's not a multiuser system. Yeah, you can have multiple users, and they can see each others' tasks, but you can't assign a task to another user.

None of these are huge problems for me, but it would be nice if they were fixed.

Bitt, this is awesome. Thanks for letting us see the work you're putting into this.

After all the tools you've tried out and all this work you've put into it, I love to imagine that your list - with dependencies - looks entirely like this:

1 Buy milk
1a find car keys

Is it open source?

Are the authors/company fairly open to feedback/patches/bug reports?

Perhaps you can get it to be a little closer to perfect with some appropriate communication.

EDIT: Looks like it's Ruby-on-rails/MySQL and licensed with GPL. Nice.

And on GitHub.

Here's a simple new app that doesn't quite match what you want in that, while you can sort of specify prerequisites, it doesn't actually track or constrain based on dependencies. It's still very young and I like to think if you pointed them in the direction of this thread they would see the utility in the functionality you're seeking.

https://hollyapp.com/