Apologies to any names I’ve misspelled, product names I’ve left out, etc.

<h2>Me, Live (ish)!</h2>
 <ul>
 <?php

 // Create a new SimplePie object
 $feed = new SimplePie();

 // Instead of only passing in one feed url, we'll pass in whole list
 $feed->set_feed_url(array(
 'http://feeds.delicious.com/rss/beau',
 'http://dentedreality.com.au/TwitterProxy/TwitterProxy.php?strip_replies=true&create_links=true&hashtags=true&strip_name=true&link_people=true',
 'http://ws.audioscrobbler.com/1.0/user/borkazoid/recenttracks.rss',
 'http://digg.com/users/beaulebens/history/diggs.rss',
 'http://www.hulu.com/feed/history/beaulebens'
 ));

 // Initialize the feed object
 $feed->set_cache_location(WP_CONTENT_DIR . '/feeds');
 $feed->set_cache_duration(3600);
 $feed->init();

 // This will work if all of the feeds accept the same settings.
 $feed->handle_content_type();

 // Now we output the combined feed
 $out = 0;
 foreach ($feed->get_items() as $item) {
 $f = $item->get_feed();
 switch ($f->get_link()) {
 case 'http://www.last.fm/user/borkazoid':
 $class = 'music';
 $strings = explode('–', $item->get_title());
 $text = 'Listened to <a href="http://last.fm/music/' . urlencode(trim($strings[0])) . '/_/' . trim($strings[1]) . '">' . trim($strings[1]) . '</a>, <a href="http://last.fm/music/' . urlencode(trim($strings[0])) . '">' . trim($strings[0]) . '</a>';
 break;
 case 'http://twitter.com/beaulebens':
 $text = 'Tweeted: ' . $item->get_title() . ' <a href="' . $item->get_link() . '">#</a>';
 $class = 'status';
 break;
 case 'http://digg.com/users/beaulebens/history/diggs':
 $text = 'Dugg <a href="' . $item->get_link() . '">' . $item->get_title() . '</a>';
 $class = 'digg';
 break;
 case 'http://del.icio.us/beau':
 case 'http://delicious.com/beau':
 $class = 'bookmark';
 $text = 'Bookmarked <a href="' . $item->get_link() . '">' . $item->get_title() . '</a>' . (strlen($item->get_description()) ? ' - ' . $item->get_description() : '');
 break;
 case 'http://www.hulu.com/users/history':
 $class = 'hulu';
 $text = 'Watched <a href="' . $item->get_link() . '">' . $item->get_title() . '</a> on <a href="http://hulu.com/">hulu.com</a>';
 break;
 default:
 $class = 'generic';
 $test = $item->get_title();
 }
 echo '<li>' . $text . ' <small>(' . $item->get_date('j M, g:i a') .')</small></li>';
 $out++;
 if ($out >= 30) break;
 }

 ?>
 </ul>

That’s it. Apologies for the lack of indentation, apparently my tabs didn’t come through properly. OK, let’s walk through it quickly.

This code all appears in my sidebar.php file (part of my custom theme), although I suppose ideally it should be a widget (maybe one day). As I said, it uses the SimplePie library, which is bundled with WordPress and is automatically available in theme files. It makes use of SimplePie’s ability to set an array of feed URLs (instead of just one) to load a couple different URLs and combine them all together.

You’ll notice that one of the URLs in there is weird-looking (http://dentedreality.com.au/TwitterProxy/TwitterProxy.php?strip_replies=true&create_links=true&hashtags=true&strip_name=true&link_people=true). That just uses another script of mine called TwitterProxy to load my Twitter updates and reformat them a bit to include links, exclude certain ones etc. The other feed URLs are all just standard URLs available from different web services I use. I could add/remove feeds on this list to include other ones in my simple activity stream.

Then I set up some configuration options for SimplePie, including configuring a specific cache directory so that I can store local copies of both the source feeds and the combined feed, rather than go and download them every time someone loads my website (which would be bad). I cache everything for an hour each time (3600 seconds), since it doesn’t need to be anywhere near live.

The next big loop (foreach…) just goes through each of the items in the combined collection of feeds and does some processing. Based on where that item came from (which source feed it was in), I set up a string for the output, set a CSS class to add to the LI and then output the item with the datestamp for when it happened. I only output the most recent 30 items across all services, and then I finish up my list and bail out.

So there you have it. That block of code in my theme handles everything for me, providing a custom activity stream on my blog. I could have used one of the available WordPress plugins like Lifestream, RSS Stream or the very powerful DiSo Action Stream, but I decided to just roll my own. If anything, I might go back and use the DiSo option at some point, since I think that project is doing some really interesting things.

Check out the KRead project page for some more details or jump over to http://kread.dentedreality.com.au/ and try it out.

Custom icons for a WordPress feed, and a Twitter search.

This version also supports Atom feeds (in addition to previous RSS 2.0 support).

Check out the latest FeedGrowler.

Check out FeedGrowler’s project page »

• TwitterProxy: Which allows you to do some cool filtering on your Twitter status feed (and then use it for whatever you want), and
• Gravatar Shortcode: A quick WordPress plugin that gives you a shortcode that you can use to inject a Gravatar into your Pages or Posts.

Check them out and let me know what you think.

For either delivery mechanism, the user would go to the site, purchase a book, then select their options for how and when they’d like it delivered. Some of the important bits would be:

1. Delivery Schedule: Daily? Weekdays only? at 8am? at 8pm?
2. Amount per Delivery: 1 page? 500 words? 1 chapter?
3. Format: Full text in email/RSS? Link to current location in online version, with their “quota” highlighted somehow?

Once you have those options configured, you’d get your periodic email (or feed, via a customized URL that would point to your specific delivery configuration) containing the current portion to read, and you would want some options in each payload I think:

• Give me more next time
• Give me less next time
• Give me more right now
• Put my deliveries on hold

This probably isn’t a business, but it’s a feature that would be pretty cool for existing eBook retailers to offer. I’d be happy to make it for someone if they want it

UPDATE: DailyLit

In amongst some work that I’ve been doing recently, and looking at my own work habits and trends, I realized that something super-useful to have would be a very accessible “microcontent storage system” where you would be able to store small snippets of information, tag them, have them fully-indexed and searchable using a simple, slick interface. Basically, I’m seeing this as del.icio.us, with more space for storing text, and no requirement for a link.

General Idea

So I see this as a series of “items”, stored with a note/body item of some sort, which would normally be text. In addition to that, you’d have an optional title and link/URL. You’d have a list of tags/keywords, and perhaps allow for arbitrary meta-data. I like the idea of the meta-data because it makes the system simple, yes extensible in ways that simple tags don’t provide (easily).

The UI would probably be largely based around search (a la Google), and would provide a list of items recently added as the default result-set. When searching, we’d probably use AJAX to make it “live search” to aid progressive discovery. I’d like to be able to save a search as well, and have that available as a navigation item of some sort (e.g. All items tagged “work” and “urgent” but note “done”). Adding an item should be a matter of clicking a link, then typing a few items and hitting a button. You’d also want a bookmarklet to be available so you could do this from anywhere. Perhaps even a Firefox plugin a la the del.icio.us one.

I’d also want RSS feeds available, specifically “recent items added” and “all items tagged x”.

Privacy controls, the ability to share items (or tags) and some other things like that would come down the line. I’d specifically like to be able to invite people to access my stream, and grant them the ability to see only items tagged with certain tags.

From here, we would also want a robust API so that we could plug the system in as the storage/backend behind any number of other apps. I see the use of POST to create new items, GET being able to retrieve a simple XML description of an item, PUT updating existing ones, and DELETE removing one. Standard REST stuff. The interesting thing here is that there’s no real reason why you couldn’t do it all with namespaced RSS (2.0) or Atom. I think that’d be a good approach because the basic structure is there, you just need to add some meta-data options which is no real problem.

The API is where the real fun lies – this could be the Twitter of… everything else. I see it as a generalized micro-content publishing system. Two immediate things that I think would be fun to plug on top of it (perhaps as paid services?) would be an email reader and an RSS reader. Basically these 2 systems would periodically check email/RSS feeds, then parse new items, tag them (using existing tags or some style of content analysis) and then POST the new item to your Stanso stream. It’d be interesting to see your email, notes, RSS feeds and potentially other things all mixed in together, tagged using a common scheme etc. Who knows where it could go? This could be a todo list, an email client, a news reader, a blogging platform, a status system, a bookmark repository, a password storage tool, a file manager, or all sorts of other things.

Technology Options

Obviously this could be built very simply using something like Scuttle (del.icio.us clone), or just from scratch using the normal LAMP stack (or RoR, or whatever). Another option I’ve been pondering is Amazon Web Services. Of particular interest are SimpleDB (still in beta, waiting on the list…) and potentially S3.

SimpleDB allows you to store a very loosely-structured set of data around a “record” in a fast-lookup, easily-queryable environment. Seems perfect for the task. It could handle arbitrary meta-data per item if you wanted, and could handle unlimited tags per item easily as well. I think S3 could be an interesting addition if you added the ability to upload a file (with tags etc), which was sidelined into S3, then automatically linked (via the URL field in an item) into your Stanso stream.

Another possibility would be to use something like WordPress to build this, since it actually handles a lot of elements of the system already (post title, body, tags, meta-data, the general blogging/posting flow). Having worked with WordPress a lot in the last 6 months though, I’d have to think that it was overkill for this, and provides a lot of other (wasted) functionality that provides more overhead than is worth adopting. Probably taking something like Scuttle and modifying it would be a best bet for a prototype at least. If building on AWS then you’d have to get pretty custom.

Possible Implementations/Features

• Simple note storage — you post small notes and snippets to remind you of things, or to hang on to passwords etc so you can find them later.
• Feed reader — feeds come in, are tagged and added to your stream, you navigate by tag or by “recentness”.
• Email client — email is pulled in and automatically tagged based on content analysis, sender details, etc. Being able to add your own tags would be awesome.
• Todo list — post items that you need to do, tagging them as “not done” perhaps. When they are done, you remove that tag (or just delete the item).
• Micro-blogging — post small updates on what you’re doing, what you’re thinking etc, then publish it out from the system via the “recent” RSS feed
• Bookmark storage — as per del.icio.us, minus all the social stuff.
• File manager — with file uploads going to S3, and meta stored in Stanso, you could store things in any “structure” (via tags) you wanted.

The cool thing is that you could actually do a number of these (if not all) at once, since you would have the ability to segment out your storage/retrieval of items based on tags as well.

Of course, after I started writing all of this, I realized it was just a slimmed down version of HTFS… so yes, I really should be building that system

It’s kind of a “catch-all” expression for a lot of the things that are going on online now. It generally refers to things like blogs and wikis and sites where the user is actually doing all the work (thus the common term “User-Generated Content” or UCG).

Just to confuse things, a lot of people have started referring to a specific design style and set of technologies as being “Web 2.0″ as well. This tends to include:

• anything mobile
• anything including mapping/geo
• AJAX (a JavaScript technique to avoid page-refreshes and make things more responsive)
• widgets (which are a whole other confusing mess of their own)
• anything that uses RSS/Atom feeds

So yeah… it’s not easy to give a simple one-line answer, because it’s kinda all of those things and more. Some people argue that it’s a “revolution” of the way the web works, because “Web 1.0″ was all about companies or bigger groups publishing information online, whereas 2.0 is more about “the little guy” out there (users) controlling and publishing their own content (think YouTube, Flickr, etc). To me, it’s actually just an evolution though, a logical progression that just took a while because we had to figure out and refine the technologies to allow things to be easy enough for everyone to be involved.

That’s my take on it anyway

Keep an eye out for more here and also over at the Blendr Blog.

“So basically RSS is a way for websites to make their content (normally time-based stuff like blog posts or news) available to people in a machine-readable format (a dialect of XML)”

Hope that helps someone (else) out there!

Check it out and see if it’s useful – hopefully when combined with some other things I’m working on it’ll allow you to mash feeds up just the way you want them.

BlogLines is an RSS aggregator; don’t let that big name scare you – basically it allows you to get content from a bunch of sites, organised into your own directories and catgories, all in one place. It’s perfect for keeping up to date on news, reading your daily blogs, or perhaps receiving certain types of updates and things like that.

There’s not much I can say, other than it’s a very well-made system, it’s entirely web-based (so you can access it from all machines you use) and it has some great features which make managing your feed subscriptions really easy. Check it out and see what I’m talking about.