Recap
Following on from CoCoDa: Issues đź—’ #codecollab a discussion on our internal IRC sparked off.
The discussion began with the exploration of a zipper version of threads spurred on by this comment.
Let’s recap what we’re actually talking about here. On our issue tracker we are modelling conversations. These conversations are a bunch of comments that go back-and-forth between project collaborators. In GitHub an issue has one central thread and we can only reply to this single thread. This becomes really confusing as conversations begin to interleave and you get something that’s hard to follow, for example: https://github.com/ghc-proposals/ghc-proposals/pull/111.
To remedy this radicle wants to have a threaded model. This means that we can reply to comments. Here we reach a decision path. Do we want to be able to reply to any comment and thus create threads of threads, like in Reddit, or do we want to only be able to cap threads at the main thread level. Here we want to follow the Zero, One, or Infinity rule. So Zero is that there is only a main thread, One means that we have threads off of the main thread, and Infinity means we can have arbitrary nesting of threads.
To demonstrate, here are the One and Infinity rules as graphs (we’re disregarding Zero due to the above reasoning).
One might remind you of conversations on Slack, whereas Infinity might remind you of conversations on Reddit.
So there’s two choices and we’d like to weigh up the pros and cons for both to help make a decision on which model we would like to go for. So here we go…
One
The Pros
- The graph is clearly much simpler, which [should] leads to a simpler semantics for definition and navigation of the tree.
- The threads are focused on the direct parent and won’t get lost in any deep right nesting. You keep the conversation focused on the topic, with one degree of freedom for discussing the relevant comments to the main thread.
The Cons
- The granularity of the conversations are limited. A sub-discussion has to break out somewhere else, or we would end up in a similar situation of having just one main thread. Breaking out an issue from a thread might be seen as a good feature though, to make sure that issues are tracked correctly.
Infinity
The Pros
- Conversations are much more free flowing. They can be in the context of any other comment, so there can be a finer granularity to each conversation. Your sub-thread about different types of trees in graph theory won’t clog up the parent conversation about threads for issues.
The Cons
-
The graph sprawls out deep and wide, making navigation of the tree structure a little bit trickier.
-
The granularity of the conversations comes at a cost. Think about how deep click during a Reddit scrolling session, you won’t go very far (assuming you scroll Reddit like I do
). This means that an important conversation might get lost in the deeper levels of the tree.
All Things Being Equal
Well, now that we weighed up the pros and cons we’re going to reveal that we can represent one graph as the other with a few tweaks.
If we wanted to go from One to Infinity we do just as we do in mathematics and just keep adding One. As mentioned in the cons above, we could simply clone a thread into another issue and link the two, possibly via another comment containing the link. So now we have a new main thread that can have comment sub-threads, and we can repeat this process ad infinitum.
On the other hand, since One is a subset of Infinity we can “collapse” the branches that nest deeply into their common parents, as long as we can merge the nodes based on some sort of ordering. This means we could pick a comment on the main thread, and collapse all its children into one single thread.
What To Do…
So here we are, I at least feel like we just went in a big circle, back at the start again. Both graphs are feasible implementation-wise, but deciding which one is necessary to continue with the implementation of the issue tracker, and depending on our choice decides which kind of features we would like to include, such as easily creating a new issue from a thread (thank you Discourse for this inspiration).
I think the choice boils down to usability and user experience. Whether we want very focused conversations within an issue and break out new issues from there, or we want find grained conversations within an issue.
I think I personally fall in the former camp, but where do you fall?
Let me know my fellow radicles 
