In The Third Generation of Weblogging I wrote the following about ThreadNeedle:
I discovered that my original concept was infeasible because of the space requirements and the forced centralization. Now, with trackback and increasing uses of other technologies, we’re starting to see ‘threadneedle’ take form, and we’re finding that what was wrong with my original concept is that it was based on one technology — threadneedle is not one single technology, it’s dozens created by as many or more people, all focusing in one way or another on Conversation — not hits.
ThreadNeedle is a concept whereby we can track a conversation, not just a specific post or weblog. The original idea was to have an application that people could use to register their ‘conversation’ threads, so to speak, and then one can see the whole conversation at a glance.
As I mentioned, a couple of problems arose. First was the fact that I couldn’t afford the server necessary to do a truly effective job of storing the information for all of the threads. However, I could have passed the hat for a server, but that led to the second problem — usability.
All the approaches I explored required additional effort on the part of the user. More than just a little effort. To start a conversation they would have to register it with a service, and then each individual conversation thread would have to attach themselves deliberately to the thread.
Well, after careful study, I’ve come to a conclusion about webloggers: we’re all here because we want to write. We’re not here because we want to fill in forms, tweak RSS, hunt down esoteric applications, compare each other’s byte length, or twist our arm behind our head to kiss our elbow, no matter how satisfying the experience.
Sure we have people who like to tweak tech, and we all benefit from the tweaker’s efforts. However, even the tweakers don’t want to have to do a lot of administrative stuff just to ensure connectivity. If it can’t be automated as much as possible, no body really wants it.
At about the same time as the discussion on ThreadNeedle was happening, Movable Type released the concept of Trackback — a way of pinging another weblog and letting them know, automatically, that you’re linking to them. If the person’s weblog was set up for it, the trackback item would be automatically added to the list of trackback items for the post.
I was asked at the time if Trackback wasn’t ThreadNeedle, and I said yes it was, and no it wasn’t. The biggest problem with the first release of Trackback was it’s dependency on Movable Type. Of course, that all changed when Movable Type released the Standalone Trackback application that anyone with a server that supports CGI can use.
At first, the use of Trackback was light, and then Movable Type added Trackback auto-discovery to posts, and next thing you know, we’re seeing trackback items everywhere. Additionally, other weblogging tools such as Bloxsom have integrated its use.
By now, to all intents and purposes, Trackback is ThreadNeedle — the embedded RDF/XML to provide information about each ‘thread’, paired with the services to track an individual thread. All that was left was pull it together. There is an application, mt-thread.cgi, included with Movable Type that allows one to see an entire thread, cached, but I haven’t seen its use. The reason for this is, in my opinion, that we don’t necessarily care to see an entire thread at a time — not really. If we did, we’d be using mt-thread.cgi. (See demonstration of this at Six Apart.) I think what we want to see is the conversation above us and below us. In other words we want to see who’s linking to us, and our readers want to see who we’re connecting to (not always in the links in the post). At least, that’s what I’m curious about when I read a post.
(And to be honest, I don’t think many conversations go beyond the three levels.)
Based on all of the above, time for a new plan — ThreadNeedle on a diet. And I’ve implemented three new pieces of functionality at this weblog as part of this plan.
The first implementation is to list out trackback items, including making a small modification in the Movable Type Perl modules to support page individual archive page re-builds with new trackback entries. This change lists all trackback pings received with each individual posting page, showing just above the comments.
The second change, showing in the sidebar of the main page, is a listing of the most recent trackbacks the weblog has received, and which post received the item. This is directly below the Recent Comments, and I implemented it as part of my effort to ‘bubble up’ recent activity on the weblog — comments, entries, and trackbacks.
I implemented this piece of the functionality in PHP, going directly to the MySql database. It’s still in test, but when finished, you’re more than welcome to have to code, to integrate into your page if you use PHP. (Another variation could use a Movable Type plug-in for the same effect. If this isn’t handled by LazyWeb next time I have some spare cycles, I’ll do this myself.)
The last change I just added today. In each individual posting page is a section labeled with Sticky Strands and listing all of the TB pings the posting issued. The functionality I added today takes those pings, follows them back to the posted weblog, and then lists all of the trackbacks that weblog posting has received.
So, for example, if you access the weblog posting for Suffer the Little Children, at the end of the posting, you’ll find the Sticky Strand section. Clicking on either of the links will then display a page containing the trackback items for Jonathon’s post or for Loren’s — including a reference to the directly trackbacked post, itself.
These weren’t incorporated directly into the archive page because I don’t want these to be PHP. In addition, I don’t want to strain the CGI at the tracked site by accessing their trackbacks unless a person really wants to see them.
With these changes, you can now see excerpts and links for posts that trackback to my post, as well as being able to see trackback items for a post or posts I reference in my own writing. Three levels of the thread.
Of course, this is still in test, and I’m still discovering the problems associated with the approach. However, I’m finding that it works quite nicely. However, note that the code for the last change works only if a person is using the standard trackback *ping* format, below:
http://yourserver.com/cgi-bin/tb.cgi/[TrackBack ID]
Movable Type and Trackback Standalone users get this automatically if you followed the documentation. I have no interest in tracking down variations of how trackback is implemented; If you’re not using this format, then the program fails. My philosophy is that if you want to play and do things your way that’s fine — don’t expect me to change my world accordingly.
Again, I’m testing the code out but once it’s working, I’ll bundle it niecly, with instructions, and you’ll be welcome to download. Implementation on your server should be trivial. At this time, all the solutions are PHP-based, primarily because this seems to be the most universally implemented solution available to most of us. If there’s enough interest, though, I’ll create implementations in Perl/CGI, too.
It’s not my grand idea of long ago, which went the way of most grand ideas, to the great Grand Idea Never Implemented afterlife — but it is a tiny thread. And a little needle. It works, its distributed, and requires no particular processing power other than to implement Trackback.
Now do you know why I’ve been on your butts about Trackback so much lately? And if you’re not using Movable Type, and can’t implement the Standalong TB server, tell your blogging vendor to add Trackback. Let’s get this show on the road.
Update
P.S. Trackback is the creation of Ben and Mena Trott. Additionally, Timothy Appnel just came out with a Perl module for trackback, XML::Trackback that should prove useful for future efforts.