A way of capturing the structure of argument. An example of TypingNotCategorizing
It's a simple threaded discussion forum, but one where contributors are required to give each posting a "type" selected from the following set : ("counter-argument", "counter-example", "gainsay", "supporting argument", "supporting example", "agreement", "extrapolation", "exegesis", "summary", "reminds me that", "joke", "troll", "garbage") to describe the relation to the parent post.
Some points :
A first draft is up here : http://www.nooranch.com/critical/main.cgi aimed at CriticalRationalists.
Originally I wasn't going to release the code because it's pretty lousy (it was my first attempt at doing CGI in Python, and I suspect very badly structured. Instead, if you're a coder looking to do something with TTD, you're better off starting with a good existing ThreadedDiscussion forum and trying to add typing to that.
But then I figured, why try to force your decision. The code exists, it does work (apart from the TrackBack thing, which probably wasn't a very good idea anyway.) So [here it is]
The point is that you use it pretty much like any other Threaded Discussion, for the same kind of questions and answers, debates, flame-wars etc. With one extra action required : ticking a checkbox as you post. However, when a new user comes to a discussion that already has 40 or 50 replies they see the structure of the existing discussion much more clearly. They can see where the arguments are, the questions, the side-tracks into amusing annecdotes. And they can organize their browsing accordingly. Do they think the counter-arguments are most important? Or the evidence? Or the jokes? Or the exegeses?
If it's easier to find the responses of a particular type, you'll be less likely to repeat them. Say you want to request some clarification on a particular post and there are 15 replies. In a normal threaded discussion forum you can check out all 15, but you might be tempted to simply ask your question again, because 15 is a lot of threads to scan. In TTD, you'll see that, of those 15, in fact only two are further questions, the others are adding supporting or contradictory evidence. Two is a lot fewer to check than 15 so, you acccept the cost of looking at them first, to see if you're question is already addressed.
Is that the best structure for complex arguments? See ADocumentIsNotATree
Hmmm, sounds good (I hadn't been as convinced when I saw this page on MeatBall, even though it contained the same thing :)
Two comments :
Hmm, I'm adding extra types everywhere here, I'm not sure it would help. Other possibilities :
Wow, I'm designing some big DancingBearware there :) maybe it's more ambitious / complicated than type threaded discussion, and maybe it doesn't add that much. I see it as a system where organizers are as much valued in the community as posters. A lot of the work can be into finding similar arguments and linking them together, classifying the best arguments, allowing to relabel your post as "hey that bloke over there just said the same thing only better, go see him instead" with the corresponding impact on the thread representation (your post may become a "reformulates, but not as well" answer to the better post) ... of course this may bloat and require a dreadfull rating system / trust metric, but it may be possible to take some of these ideas and make something out of them that could work for a small community -- EmileKroeger
Well, the main reason for TTD, and the difference with something like ClaiMaker, is that this is a quick hack. The idea of TTD is to be minor increment to ordinary threaded discussion forums, the kind you see stuck to sites all over the internet.
So, in my conception, who'd use it is anyone who currently uses threaded discussion forums ... SlashDot users, Kuro5hin users, extremevbforum users. And the kind of knowledge that is being marked-up is just the usual chatter on those fora. (Note, TTD isn't meant to be suggesting any particular ontology for marking up the arguments. I'd expect each community to establish their own. )
This is one reason why I never released the code; the world doesn't need a new code-base, it needs someone to hack the idea into SlashCode or the ArsDigitaCommunitySystem.
But actually I may change this stance; as SituatedSoftware points out, a non-scaling, prototype code might suit small groups. The other place I'd love to see it tried is on the intranet of a university department. I keep meaning to organize this with my friend who teaches in the local philosophy department.
I need to check out ClaiMaker though. Output in TouchGraph format is a good idea. Do they plan to integrate with TopicMaps / SemanticWeb ontologies?
-- PhilJones
I said TTD was one of the coming technologies of the next couple of years over on TrendPredictions/October2004.
GrahamLally wrote a good comment in response. But I've been a bit dictatorial and moved it back to the TTD itself :
There are a couple of meta-comments I'll make here though. Clearly, it's not easy to have a TTD discussion without TTD beoming the topic of conversation itself That shouldn't be surprising, AllMediaTalkAboutThemselves (it's one of the ways NetworksCreateValue, by talking about themselves they actually move to a more abstract representation of the discussion and the problem)
But at the moment, discussion about TTD tends to swamp any other discussion you have there and even prevents it starting.
So I have two hats :
More importantly, all suggestions as to how to make it more initially viable and obvious are very welcome.
This is why I'm trying to not come across as to pooh-poohy (is that a word?) about TTD - because I like the idea :) And without the TTD prototype, I suspect my brain wouldn't be mulling over how it could be improved whilst keeping the fundamental premises in sight.
If I get the time, I might try and throw some perl scripts together to do something, but in the meantime, here's my thinking.
1. Why force people to split their missives up into small, atomic blocks, when they already have them to an extent, in a manner that's easier to read, write and think. Basically, parse incoming text and treat each paragraph as a separate chunk of text which can be related to any other chunk of text.
2. Is a single relation type appropriate, or could it adopt a more layered/conglomerated approach, a la Slashdot say, so that a poster can assign a few different response types to their answer in one go (e.g. "[humourous, counterpoint]"). Similarly, other people who don't agree with the categorisation offered, or want to add some where there is none, can "rate" the relation as they see it. This still lets conversations be sortable and/or machine-readable.
3. Allow people to classify their paragraphs as they type in a semi-wiki-like style, e.g. precede them with "[explanation]". This means you can classify your response while not having to break it up into lots of actions and break your flow.
4. Allow any paragraph to be related to any other paragraph in the thread/system (maybe via some unique URI). By default, replies to a message are naturally attached to the preceding paragraph and have some generic "response" relation type, but it may serve as a response to another point elsewhere too.
This partially comes out of my love of e-mail, I admit. I think you could easily combine TTD with e-mail lists, allowing people to classify their paragraphs as per #3, and then getting people to "moderate" relations in a web-based GUI later. (You could easily post via the GUI too.)
Maybe I'll give it a go, maybe I won't. I figure I might as well post the ideas here to see what people think anyway... -- GrahamLally
TTD is the prefix, what is the suffix?
Seems like this structuring of conversations could also have a reviewing/rating/ranking component
There are some examples in the XpertWeb and ActiveBookmarks pages but Moodle (GPL E-learning http://www.moodle.org) rates its forums like this
Perfect answer!(value="7") Some good information(value="6") Supportive(value="5") Fairly helpful(value="4") Fairly neutral(value="3") Not very helpful(value="2") Way off topic(value="1")
Could be another navigational aid
-- Rup3rt
Rup3rt, a couple of points.
-- PhilJones
"D'oh!" "agreement" "Final Word" Yup, conversations are most often rated by their durability. I saw from ThreadedConversations that most threads only contain two messages. I am still keen to spot the fulcrums of threads or conversations - these should show up in the patterns of TTDs.
Rup3rt
Have you done any more on this, it sounds very promising, a way to focus on the conversation rather than scoring points, raising the collective value? Have you ever come across SpeechActs?? - kk (requesting information :)
kk,
I still think the idea is very promising. But no-one else seems particularly enthusiastic. I think there are several possible reasons. The obvious one everyone mentions is that it's too hard to identify what type to give the link. Typing the link clearly needs some extra thinking by the user, and that turns out to be a show-stopper. Less the "choose a type" itself part I suspect, and more the implied constraints it puts on the post : you should really split a complex response into several different replies; and you must choose one of several possible types. I think these feel very constraining. The cognitive overload is too much. (Maybe the types themselves aren't that good too.)
Of course, the whole point is to force a little bit of extra work out of the user, in exchange for a global payoff. But no-one is buying. That brings us to the second issue. TTD was intended to solve the kind of situation you get on something like SlashDot where there are 800 responses to a post, some of them excellent, but it's hard to see the good and relevant stuff amongst all the junk and posturing. I think even the system I have now would start to show its value in such circumstances. But with my hardly visited toy, the number of responses is too small for the typing to add any value. Potential users see the extra pain but not benefit.
The obvious answer to that is for me to take a long argument or discussion and mark it up myself, manually. That way I'd be able to demonstrate the value of information organized this way. That will take some time though, which I don't have at the moment.
There are two other relevant points to make. One is sort of positive; the other is sort of negative.
On the bright side, there's all this excitement about tagging / FolkSonomies. That has something of what I was getting at : a little bit of locally based, easy to add, relative classification which nevertheless, when aggrogated, adds a lot of value. (What I rather badly labled TypingNotClassifying) So, I can claim that the success of tagging vindicates some of my intuition. And it may inspire people to look for more of this kind of thing, and to reconsider moving in a TTD direction. Less positively, it may be that the real key to tagging's success is the lack of perceived constraint as the user can add any tag he or she likes. TTD is, in contrast, more constraining. And perhaps permanently on the wrong side of some cost-benefit calculation.
The negative point is this. The ability to type links was one of the earliest features I added to SdiDesk. It's not that clunky. Yet I never use it myself on my personal copy. In the context of my personal information management, it hasn't been so useful. Of course, TTD is meant to make arguments navigable by outsiders. I don't need it because I know my stuff pretty well. In fact the most frequent link-typing I do is here on ThoughtStorms with WarpLinks. So it might not be important, or it might be an indication I'm wrong about the value of typed-links.
Like I say, it seems to me that the secret of "selling" TTD is going to be manually preparing some examples of large-scale arguments. I'll try to have a go at that sometime this year.
All other suggestions welcome. Cheers.
-- PhilJones
ps : no, what are SpeechActs?? Do you mean in the J.L. Austin sense?
Contrast :
See also :
![[Home]](./ts.jpg)