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.
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.
> 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.
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 :)
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
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.
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? ...
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# --^
Ideally then, given all these tasks and their dependencies, what should I work on next?
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.
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.
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.
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.
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.
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.
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.