[darkteflon]

I’ve been a paying Todoist customer for many years. For some reason, they steadfastly refuse to introduce blocking/blocked by flags.

It seems so strange to me to do all the hard work of allowing arbitrarily nested projects and tasks, sub-tasks, labels, complex filters and collaboration, but then not do dependencies. Imo dependencies is the big difference between something you can use on complex projects, and a “mere” to-do list - even one with nested projects, labels, filters, whatever.

I thought that perhaps I wanted a Gantt chart tool and spent a couple of months going down that route. At least in my experience, though, what I actually wanted was just some way to establish a DAG - I didn’t even necessarily need a way to visualise it, just the ability to group and filter on it.

Vikunja looks interesting - open source, self-hosted and supports dependencies/relations. No iOS mobile client at this time, though.

[TeMPOraL]

This. To me, it seems like a weird market blind spot. Most of the tools in this space can't even do a proper tree - typically they limit you to 2-4 levels, like "project", "task", "subtask" and "checklist". The few that don't, stick to the tree model, even though work naturally structures itself into a DAG.

From the other end, I know MS Project has pretty much all the things you need, but has questionable UX, is quite buggy (I've personally managed to brick it after running auto-scheduling on a project with ~20 tasks...). There probably exist tools with the correct representation, perhaps even better UX - but I've never heard of any. Neither did a project manager I know, in a decades-old company with well established "classical engineering" culture, which includes all the PMBOK-related concept space.

And if I'm doing my semi-regular project management rant once again (a subset of more general ranting that, on Mastodon, I started to tag as #ItsAGraph, #NotATree), let me pile on some extra wishlist items: counterfactual modelling, conditionals, probabilities. That is, expressing the idea that there are alternative strategies to pursue, and which one to take depends on information available only partway through the project.

[michaelsalim]

I made Recall[0] which is all about this. Managing tasks using a tree structure (like folder/files, no level limit). And dependency representation with DAG graphs. Give it a try, you might like it.

Unfortunately the project is currently paused since i can't figure out how to make it work financially (you can still use it though). The space is really crowded and most people don't really think about dependencies, so it's quite a hard sell.

I might open-source the project and continue with it in the near future but I'll need some validation that the tool is useful before I commit to that. So if you do like it, I'd love to have a chat :)

[0] https://recalllab.com

[cjbprime]

I wonder if there's a site where someone trying to work out whether to continue a business could post how much money they would accept to instead open source it, and then that amount could be crowdfunded by its users, or just people (this would be me in this case, I guess) who aren't current users but think it looks like it would be a valuable contribution to the world.

[TeMPOraL]

On mobile now. I skimmed the landing page and this looks interesting, I'll check it out after the weekend. Thanks!

[solarkraft]

> I started to tag as #ItsAGraph, #NotATree

Oh, epic! While I do agree that most things that are modeled as yes are conceptually actually graphs, maybe my standards are lower/I just use worse software - I'd be very happy to get more trees. My typical rant topic is "just give me a damn tree". The worst offenders regarding this I can think of are note apps with their weird "notebook", "chapter","page" concepts rather than just letting me choose the depth of nesting I need.

[TeMPOraL]

I feel the pain. So much software doesn't even expose a proper tree, much less a DAG. But that seems to be improving somewhat - I see trees in software more often. I just worry I'll retire before the ecosystem makes the cognitive jump to start implementing/exposing DAGs.

> I can think of are note apps with their weird "notebook", "chapter","page" concepts rather than just letting me choose the depth of nesting I need.

Exactly! And then you end up using "outliner" software for this, and then people are surprised that you need rich text capabilities in it. In reality, what's needed is to combine both, to get a note-taking app with arbitrary nesting levels.

[TylerE]

Sort of feels like an extension of the 0/1/many concept.

[lonelyasacloud]

> This. To me, it seems like a weird market blind spot. Most of the tools in this space can't even do a proper tree - typically they limit you to 2-4 levels, like "project", "task", "subtask" and "checklist". The few that don't, stick to the tree model, even though work naturally structures itself into a DAG.

I did wonder that myself. But having tried implementing, I'd wager that deep many-to-many parent-child relationships are not directly visible more often is because no one has figured out good paradigms [1] to surface the functionality in a way that users would want to use most of the time (witness MS Project) versus the alternative tags, saved search, etc approaches.

[1] It's a fairly chunky challenge. Consider for example, what happens, and how is it presented to the user during the simple operation of removing an item. What happens when it has multiple parents? What about if it also has child dependencies? What about if some of those children have different ancestors? And it must be undoable and also needs to be usable on the limited screen estate of a mobile phone? ...

[TeMPOraL]

> I'd wager that deep many-to-many parent-child relationships are not directly visible more often is because no one has figured out good paradigms [1] to surface the functionality in a way that users would want to use most of the time

I suspect that might be a big part of the reason. I believe [0] that one big change that happens when you "upgrade" from a tree to a DAG is that you lose the ability to visualize your model in a compact and direct plaintext form

Sequences you can print an item per line, or separate by commas. Trees you can visualize with indentation, possibly decorating with some form of arrows. But DAGs seem to require you either use indirect references[1] (or duplication, which is just a more verbose and limited form of references), or give up and start drawing arrows and boxes. There's a qualitative jump in difficulty here - you (or rather, the software) needs to start thinking about layout, which is pretty much a non-issue with trees.

The biggest problems are with the evolution of the data structure. Trees and sequences don't "jump around" when you add or remove single nodes - edits cause, at worst small local rearrangement, and the rest of the tree is shifted to make/take space. DAGs are the first stage in this "from sequences to graphs" progression at which any single edit could force you to re-layout the entire visualization to keep it readable.

I have one nit though:

> And it (...) also needs to be usable on the limited screen estate of a mobile phone?

This is true now, but it wasn't true just a few years ago. Where are all the products from the last decade, that didn't have the "design for smartphones" constraint?

--

[0] - I strongly suspect this to be a mathematical fact, but I haven't encountered a proof of it.

[1] - If you want to keep parents next to their children, you're almost always forced to start doing things like:

  #1=Parent1 ----v
  Parent2  ---> Child1

  Parent3 ---> Child2
           #1# --^

... which kills readability, as now the reader has to keep a cache of those labels and dereference pointers in their head. If, instead of references (like #1#) you just duplicate the node (e.g. write "Parent1" again), the reader still has to keep a mental map of which nodes are represented multiple times in the text, and which are just similarly named.

[thijser]

Have you tried Trilium (https://github.com/zadam/trilium)?

It's a generic note storage (with a DAG based model) that's very extensible and comes with a demo task manager implementation: https://github.com/zadam/trilium/wiki/Task-manager

[TeMPOraL]

Thanks for the link, I haven't seen it.

Skimming through their Wiki, it looks like a tree-oriented outliner with a link graph - i.e. a similar model to what Roam, Obsidian, Logseq or org-mode (especially when paired with org-roam) offers.

This is as close as I've seen graphs at the UI level to hit mainstream, and the extreme hype generated around this class of tools (and Zettelkasten) when Roam showed up was interesting to watch - people reacted to this as if it was pure magic.

[gala8y]

I had a quick look at demo and dependencies are here, which is, as you mention, good and rare.

I don't want to steal the thread (lets focus on Vikunja), but I currently use Obsidian and am trying to achieve DAG with creating taxonomies using some extra plugins like Dataview and Breadcrumbs. It's basically `markdown notes connected`, which allows lots of freedom in creating such taxonomies. It is still not easy to visualize it all the way I imagine it. I would really like to have it visualized after all, think seeing it all visualized (and even being able to work directly with it) helps a lot.

For me it is a big step from not-so-useful lists of tasks... simple lists of tasks are simply useless for me.

[f_devd]

I had exactly the same thought on the DAG structure and tried to create it in Obsidian using some linking magic but found it really clunky, currently working on making something myself using CRDTs, probably not for a wider audience though.

[npritchard]

For what it's worth, I've also come across this problem - so I made my own solution. I call it Mondage [0], it looks like a plain todo list app, but lets you drag tasks on top of each other to set dependencies.

Tasks you can do first get sent to the top. Everything else is shown underneath. I like graph views to get an overview, but when I'm in the weeds, a list is what I want.

The web version is live, I have Android and iOS clients built too, but only in beta release. With enough interest, I'll add full scheduling and other features, but for now, I'm keeping it simple and free. It's a little rough around the edges, but hopefully someone else can find it useful too.

The space is astonishingly crowded, and while that makes things hard to stand out or get noticed, it suggests to me that no one has properly solved this sort of problem - or that it's too personal to solve properly.

[0] https://mondage.com/

[kolaente]

Do you feel like it's enough to have the system allow for annotation (and maybe visualisation) of the blocking relation? Or would you also want to have a way to let it enforce that relation so that the blocked task cannot be completed until its parent is done?

[NhanH]

Can you elaborate a bit on what it means to establish a DAG? I know what DAG is, just not sure what is the application here.

[k1t]

Rather than just a pile of tasks, the ability to establish dependencies. This task must be done before that one.

Ideally then, given all these tasks and their dependencies, what should I work on next?

[flakeoil]

Couldn't you have one main task which describes the overall task and then it has a list with checkboxes that has links to the other tasks it depends on?

When one subtask is done, you check it off.

"Ideally then, given all these tasks and their dependencies, what should I work on next?"

I doubt a system can automatically propose the ideal task to work on anyway. There will be many tasks equally important and which are blocking another main task. So you would anyway have to select something by hand.

And if you would be presented with only one task to do right now, it might not be a suitable task for other practical reasons which cannot be specified using dependencies, priorities, schedules etc.

If the system gets too advanced it gets in the way more than helps. Personally I think it's better to regularly and manually walk through the list and update priorities, texts, task states, dates etc as things progresses and changes. And then you get a good overview picture of your project in the back of your head.

[progval]

> Couldn't you have one main task which describes the overall task and then it has a list with checkboxes that has links to the other tasks it depends on?

That only works for trees of tasks, ie. when a task is a dependency of at most one other task.

Imagine you have two high-level tasks: "repair the chair" and "repair the computer", which both depends on the task "buy a screwdriver". Without support for DAGs of tasks, you would need a "buy a screwdriver" bullet point in both tasks, and remember to check both after you buy it.

[flakeoil]

I get your point.

In that case I would have created a task "buy a screwdriver" with a relatively high priority or scheduled before the other tasks and maybe link to or comment about the other tasks as motivation to why the screwdriver is needed.

In practice, when using basic to-do apps like the one mentioned here for simpler projects such as re-build the living room or a one-man software project or just some around-the-house projects then I think a DAG is a bit overkill and complicated. You would also need to remember to connect the screwdriver dependency to any new task that depends on it and also avoid creating a new duplicate "buy screwdriver" task as you did not know/find the already existing one.

For projects such as "build the next generation 747", for sure something DAG like is needed.

[TeMPOraL]

> In practice, when using basic to-do apps like the one mentioned here for simpler projects

The problem is, a big chunk of the software industry seems to be managed by basic to-do apps like Trello (or worse, Github/Gitlab issues).

> such as re-build the living room or a one-man software project or just some around-the-house projects then I think a DAG is a bit overkill and complicated

It depends on a project. In my experience, "overkill" manifests primarily as you spending too much time constantly tweaking the task graph. There's a point past which it's better to stick to a tree, or even a flat list, and use your own memory and common sense to manage dependencies. This is, however, affected by UX to a large degree - the easier and faster it is to "sculpt" the DAG, the smaller are the minimal projects for which this is better than a list + some extra cognitive effort.

With personal/single-person projects, I found that DAGs become more and more useful the more different aspects of it you have to track, and the greater the length of the project is. For adding a simple feature to a codebase DAGs are definitely an overkill. But for remodeling an apartment, or even "re-building the living room", it's a different story: this is the kind of project that has lots of independent concerns, requires ahead-of-time planning and thinking of contingencies, and will take months of you being involved an hour or three a day on average. You're not going to be "in the flow" in such project - you'll be re-entering it every day. DAGs help you understand the current state quickly, and prevent getting overwhelmed by the sheer size of it.

Though the most important thing I've learned so far is: don't overdo it. You probably don't need a 100+ nodes large DAG for remodeling a living room. Not because it's wrong, but because any new information, situation or realization will force you to remodel a part of the DAG, and you'll end up spending more time keeping the plan up to date than on the actual project itself.