I see that the discussion so far has been very linked to Gantt Charts (at list with regard to visualizing dependencies). So I would like to add another perspective on how to visualize dependencies.
As Gantt Charts display how entities are schedules, they are useful only for, well, entities that are scheduled. Displaying dependencies between the entities in the Gantt Chart is important, as it it useful to know how rescheduling one entity may affect other entities dependent on it.
However, I truely believe that it should not be the primary way to visualize dependencies. And I highly object to the notion that Dependency Visualization == Gantt Charts (which, to be fair, was never explicitely expressed here, yet the fact that Gantt Charts were the only visualization method suggested may leave an implicit impression that Gantt Charts indeed eqaul Dependency Visualization).
The main problem is that Gantt Charts cannot (by design) display all entities, only scheduled ones.
Yet dependencies are not limited to scheduled entities only. Any two entities (as long as both can be completed) can have a depencency relation between them. How will the depedencies of such entities be visualized, if Gantt Charts == Dependency Visualization?
I suggest that in addition to Gantt Charts, another way to visualize dependencies should be provided.
Such a method will need to take into concideration the following properties of dependencies:
- An entity can be dependent on more than one entity
- Multiple Entities may be dependent on one entity
- Entities of different types may be dependent on one another (for example, a task may be dependent on an entire project or even multiple projects being completed, or on a project and multiple tasks).
- It should be possible to accomplish any goal represented by an entity- that is, no “dependency circles” allowed (an entity cannot be dependent on another entity who is in turn dependent on the completion of the first entity).
Looking at the properties of dependencies mentioned above, it seens to me that a good way to represent dependencies is a graph, where the nodes are the entities. However, not any graph will suffice- the graph should be directed (which represents the direction of dependencies) and should not allow any circles.
In my opinion, a good way to represent such a graph is as followed:
(1) All entities that are not dependent on any other entity should be placed on the left.
(2) All entities that are dependent on any other entity should be placed to the right of that entity with a line connecting them.
(3) Many Entities which are dependent on a single entity or on the same group of entities can be grouped together and surrounded by a thin rectangle. A line will be drawn from the common entities to that rectangle to simplify the view (for example, if ten entities are dependent on the same 3 entities, if a single line is drawn from every entity on which the 10 etities are dependent on to each one of the 10 entities, there will be 30 lines. With the “simplification” there will only be 3 lines).
(4) This kind of grouping can also be done for entities that have the same group of dependent entities.
(5) I think that this kind of grouping can be preserved even if some entity within the group have dependencies that they do not share with the rest of the group. In such a case, a line will be drawn directly between the entities (exacly like in (1)) “passing” the line of the rectrangle. As long as the View does not look “too messy” I think this should be fine. However, I cannot provide a full definition of what “too messy” means, as it is quite complicated.
I add here a demonstration of how such a view may look like. A appologize for the poor quality.
Many apps (including clickup, which was mentioned in the discession above) treat depependency visualization as “Dependency Visualization == Gantt Chart”. As far as I know, no app has implemented any view visualizing dependencies that it not a Gantt Chart. I truely believe that this kind of feature will not only provide Fibery with a competitive adventage over other apps, but that it is also vital for fully visualizing dependencies.
I would be exhilarated to see a discussion regarding other ways to visualize dependencies other than a Gantt Chart.
Hope that what I wrote added something useful to the discussion