Recovered from the Wayback Machine.
I wanted to provide the details of my overall Threadneedle strategy to fill in some of the gaps in the material I’ve supplied to this point for comments, Trackback, and Backtrack. I also want to provide instructions on how to incorporate some of this into non-Movable Type environments.
My goal is to encourage and track conversations related to, and surrounding, any one of my posts. Ultimately, from a Threadneedle perspective, this effort will add my thread into others in a distributed conversation open to any interested party.
This multi-step guide should provide the detail about comments, trackback, backtrack and related technologies, so that you can incorporate much (or all) of this information within your weblog, regardless of tool. Read on…
In parallel with this activity, I’m replacing all of my web sites with weblogs, and enabling comments on all of my work, not just the so-called ‘traditional weblogging writing’. I’m making this move because weblogging software, with its comfortable templates and lean, but sophisticated content management is, to me, an incredibly effective tool to use for all web content management. And comments add a dynamic to my existing static pages, which should help them to remain vibrant and healthy, rather than dulled, dusty, and disused.
However, I don’t want all of this material across all these weblogs to exist in isolation, so I want to show on each ‘main’ weblogging page — not the individual pages, which should be kept free of processing — the recent comments across all of the weblogs. I could use a MT plug-in, but this would be forcing a re-build on all of the main weblog pages for each new comment issued. This is prohibitive. A better approach is a well-tuned SQL query, embedded in PHP.
At this time, I’m using Movable Type tags to track recent comments for each individual weblog. A future enhancement will use PHP/MySql to track recent comments across all my weblogs.
If you’re not using Movable Type, then, of course, you’ll use whatever comments are available in your environment. This also applies to how you would track comments across many implementations of weblogs, something I just can’t cover here because the different comment implementations vary too widely.
The second step in my threadneedle strategy was to enable Trackbacks. With this, people who link to me, or write something related to one of my posts, can send me a trackback ping. This ‘ping’ is really an HTTP call with some associated data, such as entry being pinged, the link of the remote posting that pinged me, and that posting title and an associated excerpt. The Trackback functionality, implemented as part of Movable Type using Perl and CGI on my system, takes this information and stores it along with the associated weblog posting that was ‘trackback pinged’.
In my main page is a link that opens a CGI generated page that lists all of the trackbacks that have been made against the page, along with the unique trackback ping for that entry. A movable type tag lists the number of trackbacks the entry has received and when I receive a trackback ping, my main page is automatically re-built so that this number is incremented.
Additionally, I also added trackback to my individual posting archive pages so that each is listed just above my comments. You can read how I accomplished this functionality in this weblog posting
On final change I made was to add the RDF/XML for Trackback auto-discovery. This is added to the individual posting page, and allows any tool that can process the RDF/XML to find out the trackback ping id, excerpt, title, and link associated with that posting. You don’t have to add this RDF/XML to your page, as long as you provide some other way for people to discover your trackback ping URL and identifier. But the RDF/XML allows automated discovery.
In a nutshell, trackback works by generating a unique trackback ping identifier and associating this with a specific weblog entry. Since I use MT, trackback is incorporated into my weblogging tool, but there is also a very handy stand alone Trackback Server that the Trott’s have released under Artistic license. This means you can copy it and use it, or even include it in your weblogging software distribution, as long as the code is left relatively intact, and the copyright information is kept within the code.
How does Trackback work? Following are the events associated with it:
- Write a post that references another post
- If Trackback auto-discovery is not turned on, find the trackback URL associated with the post you’re writing about, and use whatever means you have to send the trackback ping, which includes your posting URL, title, and a brief excerpt as well as the ping id of the posting you’re pinging
- If you do enable auto-discovery and the remote weblog has embedded RDF/XML into their posting, you don’t have to do anything further; however, if the remote weblog does not have the embedded RDF/XML, follow step 2.
- The remote weblog gets this ping, and pulls out the URL, title, and excerpt, as well as the trackback ping id and associates this trackback item with the proper post. It can do this because stored, somewhere, is a mapping between a weblog post entry, and a trackback ping id. Entry-ping. Entry-ping. Ping-Entry. Just like peanut butter and jelly. The grape kind.
- At this point, you sit back, feeling like Joe/Jill Cool because you’re on the hip, leading edge of technology and people are going to think you’re macho-techno-alpha-geek because you Implement Trackback. You techie hotie you.
Now, mechanically, how does TB work. First of all, TB is RESTful. You’ve seen this term used before, most likey, but what does it mean?
Without getting into gory details, REST follows a principle based on why get fancy when plain works. It uses standard HTTP calls to communicate data, rather than using the more encoded procedural call like processes to send data, such as SOAP or XML-RPC. Since all web servers provide access to data transmitted in standard HTTP calls, all web servers are already enabled to use REST.
Now you can see why people use RESTful — they aren’t just being weird.
REST makes Trackback extremely easy to work with, in different languages and within different weblogging tools, because it’s just HTTP, a little processing, and some static storage. That’s all it is.
Now, you don’t have to be using Movable Type to implement Trackback. In fact, you don’t have to be using Perl and CGI. All you really have to do is follow the Trackback Specification. To allow your site to be trackback enabled, you need to provide the technology that implements this specification, using whatever technology that works for you. For instance, the Homebrew Trackback Tutorial provides how-to implement Trackback in PHP.
The key element to this is sending an HTTP call with the required trackback info, and providing the ability to intercept an HTTP call and pull the information from it. This is combined with functionality to generate a unique trackback ping, and store the trackback information for each posting so that it’s accessible with the posting in whatever method works for you.
I know this sounds simple, and it is is you’re an experienced web developer. If youre not, and you’re not using MT, list in the comments what your weblog environment is, and what functionality can be used with your system, and we’ll see if we can’t map you to an implementation, or at least help point you in the right direction.
Rather than using Trackback, I could scan my referrer logs and pull referrers, but I’ve never been happy about this approach. I wanted to incorporate into my Threadneedle strategy a deliberate interest in being part of a conversation, and this occurs with Trackback — you have to enable it, ping me, or at least turn on Trackback auto-Discovery. No accidental tourists here.
One future enhancement I am making is to create a web page form that allows a person to enter the trackback information — link, excerpt, title, and so on — that will automatically create the trackback ping for whichever of my postings they wrote about in their weblog. A trackback entry would then appear for them in my posting without them having to enable trackback, at all. This is how the trackback works with LazyWeb.
The third step in my Threadneedle enablement was incorporating Recent Trackbacks (same as Recent Comments) as well as Backtrack. Recent Trackbacks is incorporated using PHP/MySql, and will only work with Movable Type, but you should be able to get this functionality within your Trackback implementation by polling recent entries in whatever store you’re using to map trackback entries to weblog entries.
(Again, if you need help implementing this with other systems, I would suggest writing this request in these comments, or in your weblog and trackback ping this entry. Or you could invoke LazyWeb — this is the perfect LazyWeb type of request. Something very doable, a small, one-person, fun type of tweaky task.)
My implementation of Backtrack displays a list of all trackback pings sent with one of my weblog postings (not received), listed below the trackback entries I’ve received, and labled with “Sticky Strands”. Now the trackback ping URL isn’t all that useful, so what I’ve done is created a PHP web page that takes this ping URL, adds a small bit of information to it and invokes it as an HTTP request. This HTTP request then returns with the title, link, and excerpt from the posting I trackbacked, and also a listing of other trackbacks that posting received, including my own. Both my readers and I can discover who else is participating in the conversation associated with the one posting.
How this works: Backtrack relies on another aspect of the Trackback specification, which allows a return of information formatted in RSS. To get this RSS feed, you simply attach the following string on to the URL used for the trackback ping:
At that point all you need to do is process the RSS into viewable content. My processing is based on PHP, but you can use whatever works for you. See this page for my code for Recent Trackbacks and Backtrack.
Now, a future enhancement could be to do something similar to what Sam Ruby does, which is to follow trackbacks he receives and find out who trackbacked them and so on; and follow my trackbacks to find their trackback pings sent, and so on. In other words, Sam allows a person to follow a thread all the way up and all the way down, without leaving his Backtrack page. (Here’s Sam’s Python code.)
Sam’s code works because of that RDF/XML that’s added to each page to support Trackback auto-discovery. I could implement this, but I’m hesitant, and the reason has nothing to do with technology.
I am a huge believer that one thing that differentiates weblogs from usenet or MetaFilter or online forums is the weblog itself — the unique location, and the unique look. The comments, and trackbacks, and previous postings all combine with the posting to create a unique avator virtually representing ourselves on the net.
Because of this, I don’t like putting full exceprts into my RSS files for aggregators — I want people to come here to read my writings. And this strong belief in the weblogging avatar also plays into my reluctance to extend Backtrack more than one level.
With just the one level, you can click on any of the links and go to that weblog posting, and see the writing within the avatar rather than stripped of all identifying characteristics. With multi-threaded Backtrack, it’s too easy to skip around, and you miss things. At least, this is my interpretation when I tried it out over at Sam’s. All it became at one point is just words.
Now, Sam’s idea is a great one, and the technology is cool. But for the nonce, I think I’ll keep Backtrack the way it is, same as I’ll keep my Trackback listings the way they are.
Continuing Threadneedle strategy incorporates enhancements to existing technologies, including providing email notification when a thread has received new input (such as a new comment or trackback thread) and an RSS feed for same for people to subscribe to (a Threadneedle thread RSS feed viewer? Hmmm.).
Additonally, following a thread is very doable with Trackback auto-Discovery enabled (that’s why adding the RDF/XML is so important.) I wouldn’t mind playing around with the graphics software available to generate graphical/clickable ‘maps’ of a thread in its entirety.
Lastly, I want to start a compaign to encourage all webloggers who are interested in weblogs as a mode to conversations to incorporate Trackback technology. I know there are some geeky alternatives, such as pingback, but the most widespread technique used now is Trackback. It would be nice for all of us to focus on one specification. This means encouraging non-Trackback enabled weblogs to trackback enable their tools. In the meantime, though, the Trackback specification tells users of some of the tools what they can do to trackback-enable their weblogs.
My personal to-do list:
- Encourage implementations of Trackback in other technologies for others to use.
- Finish transforming all web content into Movable Type
- Implement Recent Comments and Recent Trackbacks across all weblogs
- Create Form to allow Trackback pings to my posts from non-trackback enabled weblogs
- Enable technology that allows a person to be notified by email when a thread they’re interested in has had activity (new trackback or comment)
- Create RSS feed of a thread that a person can subscribe to
- Perhaps play around with technology that tracks a thread in its entirety, cabled with web graphics software to draw graphical/clickable picture of same
- Harrass other weblog makers to add Trackback specification capability to their tools
This is a start to documenting Threadneedle as is is incorporated here at Burningbird (and elsewhere). I’ll continue to refine this, and will gather these documents into a separate How-To Weblog.
But one starts walkin’ before one starts skippen’ before one starts runnin’ and before one goes to the moon.