Blogging Roller

Blogapps 2.1 released

2007-10-02T21:49:40+00:00

<a href= "http://www.amazon.com/dp/1932394494?tag=bloggingrolle-20&link_code=as3&creativeASIN=1932394494&creative=373489&camp=211189"> 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.

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.

Status, CC: world

2007-02-22T23:39:16+00:00

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.

ROME progress

2006-11-15T17:58:04+00:00

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.

Blogapps 2 progress

2006-11-15T17:57:15+00:00

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.

Couple more RSS/Atom articles online

2006-11-12T09:46:20+00:00

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.

New RSS and Atom articles online

2006-11-08T17:54:10+00:00

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

RSS and Atom in Action in action

2006-10-20T16:34:10+00:00

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.

The Blogapps Project

2006-10-17T16:57:51+00:00

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.

RSS and Atom in Action on Slashdot

2006-10-11T19:19:45+00:00

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.

RSS and Atom in Action at the JavaRanch

2006-09-19T11:27:46+00:00

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]

Tri-XML 2006 presentation

2006-07-29T12:12:20+00:00

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]

Last two chapters to production

2006-05-01T20:00:40+00:00

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.

Re: Experimenting with the MS Feeds API

2006-03-17T14:02:37+00:00

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.

Experimenting with the MS Feeds API

2006-03-16T08:46:57+00:00

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]

The never ending story of RSS and Atom in Action

2006-03-15T21:38:04+00:00

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]

What's up with the Windows RSS platform?

2006-03-12T12:03:17+00:00

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]

RSS and Atom in Action part II out the door

2006-01-17T13:41:26+00:00

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.

Updated blog search service comparison

2006-01-17T13:26:36+00:00

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.

Atom protocol draft 7

2006-01-02T10:41:23+00:00

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.

Atom Protocol draft 05

2005-10-12T18:27:45+00:00

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.

Status, cc: world

2005-06-20T21:03:18+00:00

It's that time again.

Roller 1.2: I spent most of last week working on Roller 1.2. Part of that work was for the OpenSolaris launch. We used Roller 1.2's built-in "planet" aggregator to create the OpenSolaris blog, aggregating together about 150 blogs into one big blog with it's own newsfeed. I had to write a little custom code to load the list of blogs, because the aggregator's UI doesn't have a bulk-load capability yet. Later in the week I spent a couple of days on <a href= "http://opensource.atlassian.com/projects/roller/secure/ReleaseNote.jspa?projectId=10000&styleName=Html&version=10151"> fixing bugs, Javadocs and Velocidocs.
Roller 1.3: We've started to talk a bit about a Roller 1.3 release to incorporate some theme management changes. We need to make it easier to manage themes and apply changes globally to all user's themes, but still allow power-users to tweak their page templates. Allen has put together a rough proposal for better theme management.
Roller 2.0: I spent a couple of days on Roller 2.0 last week, still working on the data model and the new many-to-many relationship between weblogs and users. The OpenSolaris and Roller 1.2 contininued to put me further behind schedule, but I'm still shooting for group blogging done in August.
Roller@Apache: Starting today, we're using the Apache incubator mailing lists for the Roller-dev and Roller-user lists, but I still haven't updated the wiki with subscribe and unsubscribe info.
RSS and Atom in Action: Since the chapters are out of my hands, at this point all I can do is watch the Atom Protocol list. Chapter one may be coming back from copy-edit today.

That's it for now. Again, I hope to spend the remainder of the week on Roller 2.0 'cause who knows how much I'll be able to get done duing JavaOne week. And, the week after that is summer vacation.

How Atom Publishing Protocol works

2005-06-03T11:00:14+00:00

Unlike the other RSS and Atom books that are hitting the shelves these days, RSS and Atom in Action is going to cover the Atom Publishing Protocol. So, I'm following the protocol development very closely. This blog entry is a summary of Atom as it stands today (based on Draft 04 released May 10, 2005). It's a follow up to my post earlier post Atom in a nutshell which explained Atom API 0.9.

Atom Publishing Protocol (a work in progress) is a new web services protocol for interacting with a blog, wiki or other type of content management system by simply sending XML over HTTP, no SOAP or XML-RPC required. Your code interacts with collections of web resources by using HTTP verbs GET, POST, PUT and DELETE as they are meant to be used. Here's how it works.

Discovering your workspaces and collections

To start out, you do an authenticated GET on a server's Atom URL to get a description of the services available to you. You get back an an Atom Services XML document that lists the workspaces and within each the collections available. A workspace could be a blog, a wiki namespace or content collection that you have access to via your username/password.

Each workspace can contain two types of collections: entries and resources. Eventually, the spec will probably allow for (at least) five types of collections: entries, categories, templates, users, and generic resources.

Here is an example of a services document XML for a blog user with access to two blogs "My Blog" and "Marketing Team Blog":

<?xml version="1.0" encoding='utf-8'?>
<service xmlns="http://purl.org/atom/app#">
     <workspace title="My Blog" > 
        <collection contents="entries" title="Blog Entries" 
            href="http://localhost:8080/roller/atom/myblog/entries" />
        <collection contents="generic" title="File Uploads" 
            href="http://localhost:8080/roller/atom/myblog/resources" />
     </workspace>
     <workspace title="Marketing Team Blog">
         <collection contents="entries" title="Blog Entries" 
             href="http://localhost:8080/roller/atom/marketingblog/entries" />
         <collection contents="generic" title="File Uploads" 
             href="http://localhost:8080/roller/atom/marketingblog/entries" />
     </workspace>
</service>

Working with collections

So, a workspace is a blog and a blog contains collections of things like entries, uploaded file resources, categories, etc. All of these collections are handled the same way and respond the same way to the HTTP verbs. All support paging, so the server can return a collection in easy to digest chunks. All support query by date, so you can filter collections by start and end date.

To get a collection, do a GET on it's URI (that's the collection's 'href' as listed in the services document).

The services document specifies a URI for each collection. If you do a GET on a collection URI, you'll get back an Atom Collection XML document that lists the first X number of members in the collection. If there are more than X members, then the document will include a next URI which you can use to get the next batch of members. You can also specify an HTTP Range header to restrict a collection to only those between specific start and end dates.

Here is an example of a the collection document XML you might receive by doing a GET on the Blog Entries collection from My Blog above.

<?xml version="1.0" encoding='utf-8'?>
<collection xmlns="http://purl.org/atom/app#"
   next="http://localhost:8080/roller/atom/myblog/entry/77088a1" >
   <member title="The Connells: Fun and Games"
         href="http://localhost:8080/roller/atom/myblog/entry/7700a0" 
         updated="2005-04-16T23:07:08-0400" />
   <member title="The Connells: Boylan Heights"
         href="http://localhost:8080/roller/atom/myblog/entry/7700c9" 
         updated="2005-04-15T23:06:09-0400" />
   <member title="The Connells: Gladiator"
         href="http://localhost:8080/roller/atom/myblog/entry/7700c8" 
         updated="2005-04-14T14:05:31-0400" />
</collection>

Each member in a collection document has a title and a URI. To get a member of a collection, you do a GET on the member's URI. To delete it you use DELETE. To update it you use PUT. Here's an example of the entry XML you might receive by doing a GET on the first member of the Blog Entries collection example above:

<entry xmlns="http://purl.org/atom/ns#">
  <title>The Connells: Fun and Games</title>
  <id>7700a0</id>
  <updated>2005-06-01T19:07:45Z</updated>
  <content type="html">
     Let me tear down into your heart
     Let me take a seat and stay awhile
     Let me have a half of your whole  
     Let me keep it for myself awhile  
  </content>
</entry>

To add a member to a collection, you simply POST the member to the collection's URI. If you're POSTing a new entry, send the XML for the entry (example entry XML shown below). If you're POSTing a file upload, then send the file.

That's it. Pretty simple huh?

What about authentication?

The Atom spec requires that a server support either HTTP digest authentication, which can be difficult for some bloggers to implement (depending on their ISP and web server), or CGI authentication, which can be a lot easier to implement (I believe WSSE qualifies as CGI authentication, and that's what my Atom implementation uses).

What about devices with limited HTTP support?

Some devices have crippled HTTP client capabilities. For example, some Java J2ME powered cell phones can't do an HTTP PUT or DELETE. If you can't do a PUT or a DELETE, you can use POST instead with a SOAP wrapper that specifies a Web-Method of PUT or DELETE. Atom servers are required to support SOAP POSTS and returning results in SOAP envelopes.

What about draft vs. published states for entries?

Still undecided. Some folks suggest using different collections for entries in different states (draft, approved, published, etc.). But it's more likely that a new element will be introduced in the Atom format to specify the state of an entry.

Summary

That's my summary of Atom protocol as it stands today. I think it's a great improvement over existing blog APIs in terms of features and design. And it's not very difficult to implement. I know because I'm almost done with my server and client implementations. I hope to release them shortly for review. The release will probably be a standalone release of Roller (the Atom server) and my BlogClient UI (the Atom client).

If you see some opportunities for improvement in the protocol, please join the Atom Protocol mailing list and help out. Last call for spec changes in now slated for October. And for the Atom experts out there: what did I get wrong? Leave a comment.

Welcome to May

2005-05-01T21:02:32+00:00

Time to test the power of positive thinking: this is the month that Atom Protocol settles down and becomes stable enough for me to finish up the book.

I'm back

2005-01-27T14:01:56+00:00

Some friends and I took a couple days of vacation in the North Carolina mountains. We were trapped in the house (pictured in the previous post) for most of the weekend, due to the extreme cold and a very icy road, but there's a full-sized pool table in the house, so we had no complaints.

I'm sorry if I have not returned your email. I was off-line for the weekend and since my return, I've been (mostly) ignoring my inbox and my newsreader so that I can finish Chapter 8: Publishing With Atom and some cool blogs.sun.com stuff that I can't talk about yet. I'm going to take a break this afternoon and tend to my mail and blog reading.

Back to work

2005-01-03T10:38:16+00:00

I spent most of the break working on the book and now it's time to get back to Roller. Bugs have been trickling in from blogs.sun.com. Plus, Matt and Rick over at Javalobby upgraded JRoller to Roller 1.0RC2 last week and that shook loose a couple of bugs. So, now there's a short list of bugs that should be fixed before Roller 1.0 final. Thanks to everybody who has helped out by reporting bugs.

Sneaky rewrites

2004-12-01T11:17:47+00:00

I really don't like the way that chapter re-writes sneak up on you. You think that you're gonna make a little change here and a little change there, but you end up rewriting the whole ^$#%^%!* thing.

Happy Turkey Day

2004-11-25T22:20:13+00:00

We had nice quiet Thanksgiving and that's the way I like it. We travelled only about 30 miles, for dinner with my parents and my brother over in Chapel Hill. We had turkey, gravy, stuffing, rice, cranberry sauce, veggies, and of course, pumpkin pie and homemade ice cream. After lunch we took the traditional nice long walk around the neighborhood and this year the walk included the muddy path along Morgan Creek.

Now, we're back in Raleigh and I'm trying to get back into writing mode. I'm going to put the XML-RPC and Atom Protocol chapters on hold for a couple of days and work on revisions to the first 1/3 of the book. Reviews came back overwhelmingly positive, but that is just not good enough.

I've got a lot to be thankful for, but right now I'm most thankful for my wife's seemingly infinite patience -- that, and the fact that she is taking the boys away for a couple of days so that I can work in peace.