Blogging Roller

The next releases that I'd like to announce are the Blogapps 2.1 Examples and the Blogapps 2.1 Server.

If you'd like to learn more about the Blogapps examples and server then read The Blogapps Project article at Java.net. Here's a quick summary:

The Blogapps project hosts a collection of useful RSS and Atom utilities and examples from RSS and Atom In Action by Dave Johnson. They're designed to be useful even if you haven't read the book and they're available under the Apache License 2.0 so you can use the code in your applications and you can modify and redistribute them as you wish.

What's changed since 2.0? The examples have been updated to include the latest version of ROME Propono, which means that most of them now support the final Atom protcol spec. The server has been updated to include Roller 4.0 RC5, which also includes Atom protocol support and JSPWiki 2.4. And of course, various bugs have been fixed. Here are the release files, installation instructions and release notes.

• Blogapps server install instructions
• Blogapps Server-2.1.tar.gz
• Blogapps-Server-2.1.zip

• Blopapps example release notes
• Blogapps-Examples-2.1.tar.gz
• Blogapps Examples-2.1.zip

This blog entry was posted via Atom protocol and the MatisseBlogger blog-client, which you can see in the screen-shot below (which was also posted via Atom.

What's next? Not sure at this point, but I will do another Blogapps release once ROME 1.0 is released.

In case you're wondering what's going on lately with Roller, ROME and other projects I've been working on, here's a status update from my point-of-view.

Apache Roller graduation. The Roller team voted for graduation, the Apache Incubator PMC voted for incubation and the next step is to take the resolution to the Apache board meeting, which is coming up in the next week or so.

Roller 3.1 release. We've been moving slowly on this one. RC1 was released Nov. 20 and today RC4 just about ready to go. It's possible that 3.1 will be our first "official" Apache Roller release -- depending on what happens on the board meeting. Wonder what's coming in Roller 3.1? The What's New in Roller 3.1 page is now available on our new wiki at apache.org.

Roller 4.0 development. We started the Roller 4.0 branch a couple of weeks ago and I've been spending most of my time updating and trying to perfect Craig and Mitesh's new JPA back-end. Elias outlined a bunch of IBM contributions including an iBatis based back-end. We hope to get some of those in the 4.0 and do some JPA vs. iBatis testing, but we haven't seen any proposals or code yet.

Roller-Planet. Actually, Allen's taken over work on Roller-Planet and he's implementing many of the things I outlined in the Roller-Planet mind-map. He promoted Roller-Planet from the sandbox, built a nice Struts2 UI, added a Roller-style feed/page rendering system and Roller-style caching. Good stuff. We have not discussed when to start making standalone releases of Roller-Planet. 

ROME Propono. I've been working on a new ROME subproject called Propono that will include a blog client library, an Atom protocol client library and an Atom protocol server kit. I've been quiet on the ROME dev list, but I've been working on the client bits an they're basically done. I'm waiting for final approval to commit them to ROME CVS.

Blogapps examples and server. I'm still working on a 1.0.5 release, which will include updated Atom protocol support and some bug fixes. I just haven't had the time to get a release out, but I have had some time to work on Blogapps 2.0 where I've ditched the chapter-based directory names and switched to org.blogapps packaging. Once ROME Propono is available, I'll include it in Blogapps 2.0 and drop my old Blog Client library.

The ROME mailing list has been a little quiet lately. I'm hoping to change that. Roller's built-in planet aggregator uses ROME, Roller's Atom protocol implementation does too and I recommended ROME in my book, so I'd really like to see ROME continue to improve and grow. Now that I'm focusing on a standalone version of Roller-Planet, I've got some time to devote to those goals. Last week I cleared the bug list, this week I committed some improvements to ROME's summary/content handling and next I'd like to start pushing for a ROME 1.0 release. If you'd like to see ROME thrive, please join the fun.

In my off-hours, I've started work on Blogapps 2. Blogapps is a collection of RSS/Atom utilities and applications based on the code from RSS and Atom in Action. You can read more about the project in my recent Blogapps article on on Java.net. Up until now, I've been working alone, but now the project now has a couple of committers. Ramesh Mandava (of the Java WSDP team) joined to help with the Blogapps 2 effort.

We're starting with some renaming. Instead of using chapters-oriented directories and package names, we're more logical and intuitive application names. We're also switching from package name com.manning.blogapps to org.blogapps. Later, I hope to update some dependencies (e.g. Apache XML-RPC 3.0), consolidate/streamline some of the utilities and explore alternatives to Tomcat/HSQLDB for the Blogapps server.

The Server Side posted an excerpt from RSS and Atom in Action last week. Chapter 2: Development kick-start explains how to setup the Blogapps Server and how to post to just about any blog server via MetaWeblog API from Java and C#. And if you're interested in that, then you'll also be interested in The Blogapps Project, which was published on Java.net last month.

On the O'Reilly site, Mark Woodman's How to Build an RSS 2.0 Feed is now available as an O'Reilly Short Cut, a 56-page PDF for $7.99. Marks says that he covered RSS 2.0 from the perspective of the RSS Advisory Board Profile (aka RSS 2.0.8), which seems like a good idea. And he covered ROME too.

The second installment of James Snell's developerWorks article on Atom Publishing Protocol (APP) is online. In part 2 he shows how to post to an Atom server and one of his examples is Roller. If you want to try Snell's example code with Roller, but you don't want to go through the trouble of installing full-on Roller/Tomcat/MySQL, try the super easy-to-install Blogapps Server bundle.

Here are links to parts 1 and 2 of Snell's article:

• Getting to know the Atom Publishing Protocol, Part 1
  Create and edit Web resources with the Atom Publishing Protocol
• Getting to know the Atom Publishing Protocol, Part 2
  Put the Atom Publishing Protocol (APP) to work

And now, both parts of RSS and Atom in Action Chapter 4: Newsfeed Formats are online at WebReference.com. The chapter includes a history of RSS and Atom newsfeed formats and diagrams that illustrate the elements each format.

• Newsfeed Formats, Part 1
  From the Birth of RSS to the Nine incompatible versions of RSS
• Newsfeed Formats, Part 2
  the new standard: Atom

Nick Lothian wrote to tell me about the Education.au blog, an aggregated site that uses the PlanetTool example from Chapter 11 of RSS and Atom in Action.

My Java.net article on the Blogapps Project just went live today.

The Blogapps project provides what is essentially a complete RSS and Atom development kit, which includes feed parsers, generators, blog client libraries, an Atom protocol implementation, a set of ten useful blogapps, and an easy-to-install blog and wiki server. This article explains the project's purpose and how to install and use the project's products, the Blogapps Examples and Blogapps Server, to jump-start your RSS and Atom development.

Simon P. Chappell writes "We've all seen them, those icons that decorate blogs and websites; sometimes they're just little orange squares with white stripes, while others say RSS or Atom. Many of us have heard of feeds and podcasts and aggregators. What are these things and where did they come from? Well, Dave Johnson, the author of the open source Roller blogging software, is glad you asked and by way of an answer, he's written RSS and Atom in Action." Read the rest of Simon's review.

Woohoo! Simon likes the book and gives it an 8/10 rating.

I'm doing a RSS and Atom in Action book promotion at JavaRanch this week in the XML and Related Technologies forum. That means that I'll be checking the forum several times a day and answering all of your questions about the book's topics. At the end of the week, we'll be giving away copies of the book to four randomly selected posters.

So far, I've been answering basic questions like what is RSS, what's the difference between RSS and Atom and what's the book about?

Tags: topic:[RSS], topic:[Atom], topic:[feeds], topic:[Java], topic:[Web 2.0]

Here's the abstract of the talk I gave this morning at Tri-XML 2006:

Beyond blogging: Atom format and protocol. Like XML-RPC and SOAP before, feeds and publishing protocols were born in the blogopshere and quickly moved beyond blogging. Nowadays, web service providers are using RSS/Atom feeds and REST-based publishing protocols as lightweight alternatives to SOAP. And developers are finding new ways to combine web services from different sites into new applications, known as "mash-ups" in the lingo of Web 2.0. If you'd like to do the same, then attend this talk to learn about the new IETF Atom feed format (RFC-4287) and the soon-to-be-finalized Atom protocol, which together form a strong foundation for REST-based web services development.

Here's a rough outline of the talk:

• Introduction
• Beyond blogging
• Blogs hit the hit time
• The web is bloggy
• Atom as an alternative to WS-*
  
• Understanding feeds
• Birth of RSS
• RSS 1.0: the RDF fork
• The simple fork and RSS 2.0
  
• Atom: the standard
• Parsing feeds
• Fetching and parsing feeds
• Universal Feed Parser
• ROME utilities
• Windows RSS platform
• Serving feeds
• Approaches for generating and serving feeds
  
• Feed autodiscovery
• Styled feeds
  
• Atom protocol
• Compared to MetaWeblog
• REST based approach
• Introspection
• Collections
• Extending Atom
• Atom protocol in action
  
• Getting a service doc
• Getting collections
• Posting an entry
• Posting an image
• Demo: interacting with an Atom server via command-line
  

And here are the slides: TriXML2006-BeyondBlogging.pdf

Tags: topic:[Atom Publishing Protocol], topic:[Atom], topic:[APP], topic:[RSS], topic:[feeds]

Over the weekend, I put my finishing touches on the (last) two new chapters for RSS and Atom in Action. Tomorrow they'll both be off to copy-editing, typesetting and then to the printers for publication in mid-June.

I really lucked out in the reviewer category. Thanks to Walter VonKoch of Microsoft's Windows RSS Platform team, who not only answered my questions but kindly offered to review the Windows RSS chapter. And thanks also to former co-workers Pat Chanezon and Alejandro Abdelnur, who reviewed the ROME chapter.

By the way Alejandro is back from Asia, blogging again and already coming up with cool new APIs for ROME. Checkout ROME.Mano, a pipeline framework for RSS and Atom feeds.

I'm seeing lots of interest in my MS Feeds API post yesterday, sparked by links from Sam Ruby, Dave Winer and Randy Morin. Some people might have gotten the impression that I was criticizing the decisions Microsoft made in mapping RSS elements and extension elements to the Feeds API object model. I wasn't.

I think Microsoft made pretty good choices, given the simplified object model that they're working with. If somebody is using funky RSS, then they mean it. For example, if somebody declares the Content Module namespace and uses the <content:encoded> namespace in their feed, then that's probably the content that they want folks to use. I think that's the philosophy Microsoft used in making those decisions, except for prefering <pubDate> over <dc:date>, which I don't understand.

The problem is, the Feeds API object model is a little too simple. Like RSS 2.0, it doesn't model the common things that bloggers do like having both a summary and content for each item, or having  name and/or e-mail address for each author. That's why people use extensions like the <content:encoded> and <dc:creator> (or prefer Atom, which does a better job of modeling those common things). I hope Microsoft will fix this by improving the object model and if they do, they won't have to make as many choices about which elements to use.

The Windows RSS platform includes a Feeds API that parses all forms of RSS and Atom to a simplified  object model.

For example, an Item object has an Author property and not an author name, author e-mail and author URI which are all possible in Atom. And, an Item object has a Description field and not description and content (as in Wordpress feeds) or summary and content (as in Atom feeds).

So, how does the Feeds API decide how to map elements to this  simplified object model? I did some C# experiments and here are some of my findings. Note that the Feeds API is beta software and will certainly change for the better (I hope) by the time it is released in IE7 and Windows Vista.

Item contains	Feeds API returns
<dc:creator>dave</dc:creator>	item.Author = "dave"
<author>dave@example.com</author>	item.Author = "dave@example.com"
<author>dave@example.com</author> <dc:creator>dave</dc:creator>	item.Author = "dave"    (prefers funky RSS)
<description>my desc</description> <content:encoded>my content</content:encoded>	item.Description = "my content"    (prefers funky RSS)
<pubDate>    Thu, 9 Mar 2006 23:13:04 -0500 </pubdate>	item.Date =    "3/10/2006 4:13:04 AM"    (uses GMT)
<pubDate>    Thu, 9 Mar 2006 23:13:04 -0500 </pubdate> <dc:date>    2004-08-19T11:54:37-08:00 </dc:date>	item.Date =    "3/10/2006 4:13:04 AM"    (prefers core RSS element)
<atom:summary>my summary</atom:summary> <atom:content>my content</atom:content>	item.Description = "my content"

First, it's interesting that those funky RSS elements that Winer dislikes are preferred over the core RSS elements in important places. And second, what if you're not happy with Microsoft's mapping choices in this area?

For example, how do you get both description and content from those Wordpress feeds? Wordpress (and Typepad) uses the <description> element as a summary and the funky <content:encoded> element for the full content (see Winer's own Wordpress.com feed for example). You've got to parse the XML yourself. The Feeds API tries to makes that easy by providing both the XML for the entire feed and the XML fragment for each item, but I think most developers would prefer to have a more complete object model.

See also: What's up with the Windows RSS Platform

Tags: topic:[rss], topic:[atom], topic:[feeds], topic:[ie7], topic:[vista]

You know last week, when I said the book was ready to go to the printers and would be available this week as an e-book? We'll, I was wrong.

While we waited for Atom protocol to stabilize, things changed in the world of C# and Java feed APIs. Microsoft introduced the Windows RSS platform and a pre-release of the Windows Feeds API is available in the IE7 beta. And ROME has come along way too; now with Atom format 1.0 support and a growing list of extension modules. We decided that we just couldn't publish a book on RSS and Atom without covering the Windows RSS platform and ROME in-depth. So now I'm under the gun again, writing away into the wee hours of the night. I should be done by April 14th and, with luck, the book will be out in late May, just in time for JavaOne. That explains my sudden interest in the Windows RSS platform.

The kids hate it, but I think it's for the best. Manning will have the very first book that covers the Atom protocol (with a working client and server), the Windows RSS platform and ROME in-depth. It'll definitely be worth the wait.

Tags: topic:[atom], topic:[rss], topic:[ie7], topic:[atom protocol]

The Windows RSS Platform (or Feeds API) is the feed handling engine that powers the new RSS features in IE7. It will also be included in Windows Vista for use by other applications. Note that here, RSS is a generic term meant to include both RSS and Atom -- the Feeds API supports both. The Feeds API is packaged in a DLL called msfeeds.dll and available to programmers as a set of dual-interface COM objects. Here are the features exposed via the Feeds API.

• Common feed list: list of feeds for current user, organized as folder hierarchy.
  
• Feed store: local cache of feeds, feeds available via abstract object model
  
• Download engine: for managing and monitoring large enclosure downloads
  
• RSS sharing extensions: new XML elements to support bi-directional sync via RSS

The Feeds API gives you access to the current user's feed subscription list, a feed parser that can handle any form of RSS and Atom as well as the IE7 podcast download engine. The parser parses feeds to an abstract object model designed to represent any sort of feed. It handles funky RSS and in some cases prefers the funky elements (e.g. <content:escape> over <description>).

I'd like to learn more about how the Feeds API decides which elements to use, how sync works, and how the whole package compares to the premier Java Feeds API ROME. So, I've downloaded IE7 and started experimenting with the API from C#. I'll be posting more on this topic in the next week or two.

Here are some of the references I've been using to understand the API:

Feeds API docs, specs and whitepapers from Microsoft 

• The Feeds API documentation at MSDN Library
  
• The Simple Sharing Extensions (SSE) for RSS and OPML specification
• The Simple List Extentions for RSS specification
  
• Simple Sharing Extensions for RSS tutorial (in Vista only?)
• RSS Support in Longhorn - good overview
• PDC05 presentation about RSS in Windows Vista

Microsoft employee blogs about the RSS platform

• The Windows RSS Platform described on the Microsoft RSS Team Blog
• The Windows RSS Platform ala carte from the  Microsoft RSS Team Blog
• A blog about the RSS Simple Sharing Extensions from Microsoft's Jack Ozzie
  
• Related: Ray Ozzie's blog post Wiring the Web
  
• FeedBandit developer Dare Obasanjo's feedback on Windows RSS Platform
  
• Windows Live Mail Desktop Beta (RSS feeds and "blog-it" feature)
  

Other blogs about it

• Newsgator's Nick Bradbury's feedback on Windows RSS Platform
  
• PDC'05 blog about the above Windows RSS Platform presentation
  
• Jim Mathies built an aggregator in a weekend with the RSS platform
  
• A simple windows RSS store viewer and exploration of msfeeds.dll implementation
  
• John Udell interviews Microsoft's Amar Ghandi about the RSS platform

Update1: added a couple of new links suggested by Mark Woodman
Update2: added reference to Simple List Extensions
Update3: added link to RSS in Windows Vista presentaton

Tags: topic:[atom], topic:[rss], topic:[ie7], topic:[atom protocol]

I spent Saturday rewriting the second half of my search/monitoring chapter and then Sunday and Monday I spent updating my C# examples. I also built, ran and tested all of the example code for the book and committed a number of fixes to the Blogapps CVS. And finally, I sent the whole Part II bundle back to Manning for typesetting and proofreading. The end is near!

I had been using Visual Studio C# 2003 but since that's almost three years old now, I moved everything over to Visual Studio 2005 and .Net 2.0. Moving to .Net 2.0 was pretty easy. I downloaded Visual Studio C# 2005 Express Edition and that worked fine for almost all of my examples, but not for my one ASP.NET example. I had to download Visual Web Designer 2005 Express Edition to get that working. Both of those IDEs are free at least for the next year. You can get them here: http://msdn.microsoft.com/vstudio/express. Nobody pays for IDEs anymore, not even Micro$ofties.

Lots of good feedback on my blog search service comparison. Everybody except Google and Yahoo wrote in with corrections and additions and in response I've updated the matrix.

I was planning on submitting Chapter 8 of RSS and Atom in Action to Manning today, but Atom protocol draft 7 has appeared. The changes look good and the only really significant one for me is the move from list templates, which allowed indexing into a collection, to next/previous paging as we had in draft 4. I'm going to revise my implementation, Chapter 8 and turn it in on Wednesday. Once that's done, I'll release Blogapps v0.1.

There's a new draft of the Atom Protocol available and I've already started working on updating my client (the BlogClient example from my upcoming book RSS and Atom in Action) and server (in the Roller sandbox) implementations. Surprisingly, the new spec doesn't look all that different from the previous one, so perhaps a weekend of work will do the trick.