What a difference 1Gb makes! I finally got around to upgrading the memory on my notebook to 2Gb and things sure are faster. Now I can finally start using virtual machines to do more of my testing.

After coming up blank on a robust tagging API for ASP.Net apps, and wanting to incorporate this functionality into new versions of most Speerio products, I decided to create one. Along the way, I took a good, hard look at many websites to see how they implemented the UI for tagging. In most cases, everyone ripped Flickr’s UI. This is fine, but in the process they also copied some of limitations of the Flickr UI.

I took a clean-slate approach and decided I wanted to communicate more than just popularity through the tag cloud. The relative age of an item is just as relevant as how often an item is tagged with a certain tag, therefore I decided to introduce the concept of “age” into my tagging API. At a glance, the tag cloud not only tells you which items are more popular, but also which ones have newer/older information.

This ability to convey both popularity and age through a single UI is going to be an important feature of the (clean-slate) discussion forum I am creating. Imagine if you will, a discussion forum that is devoid of categorized groups of sub-forums, with only a tag cloud for navigation. If you’re looking for a solution or an answer to a question, you can instantly find all posts relevant to a keyword of interest to you simply by clicking on it. And then, you can explore clusters of related information to find the handful of posts that are most applicable to your situation. No paging through hundreds of posts only to find content that has no bearing on your situation. And if you want to browse, just click on “age” and you’ll see the topics that have been most recently posted.

Getting back to the API, here’s a screen grab of the cloud which can be added to any ASP.Net page or control with one line of code. The entire UI is customizable with CSS and works identically on IE and FireFox (should work on other browsers too, but I haven’t tested).

I also wanted to automate the detection of clusters between tags and users. I didn’t think this was information that was relevant on the main cloud UI, so I created a context-menu which allows a user to display a cross-browser, modal dialog containing more information about the tag.

I’ll have more details about the tagging API soon and an online demo in the next few days.

Whew…another DNN Newsletter done and sent. We have some really interesting nuggets of information in this one, so do check it out. Now to sit and track the response. I really enjoy this part. It’s fun and informative reading the community’s feedback to the Newsletter and to the survey.

This edition announces the release of the DotNetNuke Benefactor Program too. A lot of thought and planning went into developing this program and it presents an interesting alternative to open source projects just going completely commercial. This program allows DNN to maintain its open source ideals, but provides a way to get some voluntary funding from the community.

It has begun. With Amazon’s announcement of the Alexa web search platform beta the index of the web is no longer the domain solely of 800 lb gorillas. Anybody who knows how to consume a webservice can tap into Alexa’s index of billions of documents. This move will truly democratize search as ideas will no longer be constrained by the need to have a massive data center and web crawlers.

If you do any file processing, you will inevitably find yourself writing recursive code to traverse a directory structure. If you have a directory structure that is broad and deep with files/folders numbering in the thousands, recursion is inefficient as it consumes stack resources. In some cases you will run out of stack space and cause the code to throw an error.

You can do this more efficiently by using a seldom-used class of the System.Collections namespace: Stack. The Stack class implements a LIFO data structure (Last In First Out), as opposed to Queue, which implements FIFO (First In First Out). Instead of deferring to the run-time to implement the stack (which is essentially what recursion does, but in an inefficient way), you can optimize the process and also prevent your code from breaking, by managing the stack yourself.

Here is a simple example that will traverse and print-out all the files in a directory structure without using recursion:

private void TraverseFolder(DirectoryInfo dir)
{
	Stack stack = new Stack();
	stack.Push(dir);
	while (stack.Count > 0)
		{
			DirectoryInfo dirInfo = (DirectoryInfo) stack.Pop();
			foreach(FileInfo file in dirInfo.GetFiles())
			{
				System.Web.HttpContext.Current.Response.Write(file.FullName + "<br>");
			}					   
			DirectoryInfo[] subDirs = dirInfo.GetDirectories();
			for (int index = subDirs.Length - 1; index >= 0; index -= 1)
				stack.Push(subDirs[index]);
		}
}

Looks like Lee Sykes beat me to the DotNetNuke lens on Squidoo. Interestingly enough, the ASPnet lens was available for the taking. I also picked up WebDAV, Tagging and Logos.

Umair could not have made a more timely post about Yahoo’s lack of innovation. He discusses Yahoo’s “hyperimitation” and how it never really improves anything in any meaningful way.

I say timely because I have now spent some time engineering a better “forums” application because I have given up on forum software available today. Many of us use web-based discussion forums everyday, and they are all the same. From the common seed of BBS many years ago, there evolved a design for web discussions — forum groups, forums, threads and posts. It all worked quite well until everybody had a computer, a browser, an Internet connection and an opinion. This has resulted in three major problems:

– It’s hard to keep up with the volume of information. With hundreds and sometimes thousands of posts in different forums, across different sites, how does one track information of interest and more importantly relevance. Email digests and email subscriptions don’t cut it. They just move the information to different client software. If you track even 3–5 busy forums, you will be innundated with information.

– It’s hard to find relevant information. Forums are notoriously hard to search because there is no meaningful way to perform contextual searches. Users freely post anything (even in moderated forums) and there is no guarantee that threads will stay focused on a topic. Keyword searches yield tons of results and out of frustration, users will often just post a question which has already been answered umpteen times.

– It’s hard to tell which user’s posts are worth reading. Just because a particular user has a high post count does not make them interesting, relevant or for that matter, credible. For instance, there are many users on the ASP.Net forums with huge post counts that have very little substance in their posts.

As some of you may have noticed, I have not been very active blogging or on the forums lately. And yes, I am also behind on releasing updates to some of Speerio products. This is because I have been hard at work doing a fair amount of re-architechting of existing products, while also working on a Speerio product suite called “Community Studio” (more on that next week). One of the apps in the suite is a discussion application. In working out the design for this app, I was tempted to take the interaction metaphor used by most most forums today and implement it, perhaps with some U.I. goodies to make things interesting. But the more I thought about it, the more I disliked this idea. There is no point in replicating a bad concept with a good U.I. — all it does is give you more of the same problems, albeit with better user interaction. A good example of this is the recent upgrades made to the ASP.net forums. Many client-side U.I. enhancements, but none that substantially help with usability and easily finding relevant information.

I decided that I would take a fresh approach to designing a web-based discussion application (I’m not going to call it a forum any more). Starting with a clean slate, I prioritized some key requirements —

1) The application should enable a user to instantly know what topics are discussed the most.

2) The application should enable a user to instantly find all discussions on a topic, prioritized by relevance, chronology or amount of participation for all time or a user-specified period of time.

3) The application should enable the user to be notified when more discussions about topics of interest to her/him emerge.

4) The application should provide the user with hints about contextually relevant topics that have been discussed when he/she searches for a topic.

5) The application should be incredibly easy to use, very responsive and should be optimized to take advantage of the one trait that is common to all web-based discussions — 99.99% of the time all content is write-once/read-many.

Looking at those requirements, it should be obvious that the group – forum – thread metaphor isn’t going to cut it. The more I thought about it, the more I became convinced that web-discussion applications have been over-engineered and the solution is not to add, but to subtract. Doing just that, I arrived at a design that is quite different from today’s discussion software, but which I think meets all the above requirements. I’ll go into detail in a later blog post, but let me share some high-level ideas here:

1) Information navigation is done using a folksonomy-generated tag cloud.

2) There are no groups or sub-groups or forums…only a flat collection of discussions (100 or 1,000,000…doesn’t matter)

3) Each discussion is natively stored as an RSS feed. A discussion is the originating post and all responses to that post. There is no hierarchical thread, just a linear series of responses.

4) Each user who posts a response, must tag her/his response with tags that are relevant to the content of her/his post. This is key because contextual relevancy is best determined by humans and not computers (at least given today’s technology).

5) Tag clusters are automatically created for contextual relevancy.

This, in a nutshell, is a design that meets all the requirements. Of course, there is a lot of detail in the implementation and the U.I., but from a 20,000–foot perspective, the design is very, very simple. While technical gurus are busy arguing the merits of a folksonomy over structured taxonomies, ordinary people are enjoying their ease of use, both for content creation and retrieval. This makes me confident that even though my folksonomy-based discussion app will take some getting used to, once users see how it makes web-based discussions easier to track, digest and retrieve, they will love it.

More design details and information on Community Studio to follow.