The Case for Flat-Threaded Discussions

As I stated in a previous entry, I've recently built and released an open source "conversation" system called Sylbi (currently in beta). This system was based on the idea that blogs with comments and forums differ very little, and there was no reason why you couldn't build a system that could be both a forum and a blogging platform.

Because Sylbi provides the ability to have discussions, that is, multiple people respond to each other's posts over time, it had to deal with how to display those conversations. The two most common ways for doing this are the flat and threaded models. For a detailed and intelligent commentary on the virtues of these methods, see this post from Coding Horror, and this one from Joel On Software.

As I began thinking about this problem, I decided that there is a third method for displaying conversations, one that I feel is preferable to the other two: threading without indention, or as I like to call it flat-threaded. Here is my conclusion, posted on the official "blog" for the Sylbi project. (You can read the full post here, which talks about this as well as the other unique features of Sylbi.)

It is my opinion that threading a conversation, that is, grouping replies to a post immediately below that post, provides the most logical organization method. Slashdot discussions are threaded, as are those on reddit. However, I think that indenting replies adds no real value, and instead actually makes the conversation more difficult to read. Sylbi threads conversations, but uses no indentation. So as you scan posts from top to bottom, post replies are clustered together, but you must use the content of the posts to determine the grouping. I refer to this as a "flat-threaded" conversation. Sylbi provides the means to quote previous posts, if this should be necessary.

Here's why I think this view works. Books are written from top to bottom. If an author refers to something that occurred in a previous chapter, you rely on your memory and comprehension to understand the reference. If the reference is subtle enough, an author may quote himself. Where a conversation is concerned, I think that memory and comprehension don't need to be aided by indentation, and where a reference may require it, you can easily provide a quote.

I am committed to "eating my own dogfood", and so am using Sylbi while I work on it. I have a live version running on my web hosting provider and use it to identify problems with my code as well as my assumptions.

One of my initial tests was of the flat-threaded view, and I created this conversation (which I unfortunately made a little difficult to read by using tons of self-references) and began using it to probe the concept. This was a discussion, so as I coded, I tested by adding to it, and eventually, this analogy fell out:

Consider a real conversation amongst a group. A topic is started by Alice, and Bob and Charlie discuss it with her for a length of time. Then, Bob touches on an individual point of Alice's initial topic, and a segue is created. Let's say that only Charlie and Bob discuss this point. Alice is silent. But she hasn't said everything she wants about the initial topic, so after they are finished, she brings them back to the topic, and they discuss it further. Bob's segue "held place" for additional comments by Charlie and Bob, and then the original topic was resumed. Viewed in a linear sense, this is exactly what a flat-threaded conversation does.

The holds place comment above is in reference to the (at least logical) "fairness" of grouping responses together. Because it is likely that a response to a post may come days after other posts have been made, and earlier posts are pushed down as this latecomer is inserted below the post it's a response to. For example:

• Initial post (entry) E [day 1]
• Response (to E) R1 [day 1]
• Response (to R1) R3 [day 2]
  
• Response (to E) R2 [day 1]
  

A response to a post becomes a subordinate post, as R3 is a subordinate to R1 above. R1 comes before R2, because it was posted earlier. So any responses to R1 get inserted directly below it, ahead of other, potentially earlier posts (R2). So R1 held place for R3, and it had the right to since it was made earlier. This is a sort of "first come, first serve for all my children" mentality. But it serves an important purpose: to keep direct responses together, which provides better cohesion, I think.

Of course, there is a caveat. The holds place idea is susceptible to gaming. For instance, if you want to have your entry appear higher up in the list of responses, you could respond to a higher level response, even if the content of your post is not particularly relevant to that one.

Taking our example above, let's say that it's days later, and there are over 100 responses. You want to post, but hate the idea of being all the way at the bottom of the list. So you pick the first response below the initial entry, and respond to it, but really, you just want to sound off on the original entry. Because you are responding to R1, the system inserts you at the bottom of the subordinate list for R1, which puts you higher in the list than other posts that followed the rules.

This is somewhat mitigated, however, by the fact that in 100 responses with no indention, it is difficult to be entirely clear which post is actually subordinate to which, and therefore where your post is going to appear vertically. It will be much more reasonable to simply respond to a post when you feel that the content of that post requires one.

On the other hand, this may simply be a risk involved with human communication, and a small one at that. Further on in the dogfooding conversation above, I observed that real human conversation is far from trouble free.

Alice starts a topic with Bob and Charlie. A segue is created, and Alice interjects that they are getting off the subject, and Bob and Charlie return from their tangent. Or they don't, and Alice's conversation is hijacked. I've also seen this conversation pattern (and been involved in it from probably all perspectives).

So I think that, basically, when talking about the "natural" flow of conversation and the mantra that trying to mimic this in a forum [is good], it should be noted that real conversation is not necessarily a smooth or clean or non-anarchic interaction. It can be, but it can also be an incredible mess, incredibly trite, or some mix of both.

Ultimately, I think the flat-threaded method provides a slightly better view of online conversations by trying to be as contextual as possible, and simplifying the presentation. However, just like real conversations, much depends on the humans.