Blogging Roller

WIP: Links

Dave Johnson — Mon, 21 Mar 2011 06:49:23 +0000

This is the first in my series of Web Integration Patterns. Check out the intro at this URL http://rollerweblogger.org/roller/entry/web_integration_patterns

Synopsis

Use links as a way to integrate web sites & applications via navigation and relationships between resources.

Motivations

Provide navigation between integrated web sites & applications
Create meaningful relationships between web resources

Related patterns

Common Navigation
Embedded Properties in HTML
Resource Preview
Delegated Selection & Creation
Linked Data & REST

The web is the web and hypertext is hyper because of links. Links allow for the most deep and also the most shallow forms of integration. Links enable navigation and with some discipline, links can also express relationships between resources. There are a variety of ways to express links; the standard and most popular way is to use HTML, but there are others and I’ll cover them below.

Links enable navigation

With links, you can provide navigation between web applications at the application, or the feature level. One example is providing a link from the blog application of a social software suite to the wiki, forums and other component applications. Another is providing a link from one application to one specific part or feature of another application. This type of linking is easy to implement but fairly shallow. It’s convenience and not much more.

Links can express relationships

What’s more useful and powerful, is using links to create meaningful relationships between the resources provided by web applications. For example, there's obvious value linking a defect in a bug tracking system to the source code changes that fixed the bug in a source code management system. Or, you might link a Requirement resource to the Work-Item resources that implement it. By the way, those example are drawn from the OSLC specs for ALM / PLM integration.

If you want to use links to establish relationships, then you do have to have some discipline about the URLs you offer and the URLs you link to. You have to treat links with the same rigor and respect you’d give primary and foreign keys in a relational database. For example, if you make a resource available in different formats, and each at a different URL, one that ends in “.html” and one with “.xml” and one with “.json” then you’ve got three URLs that refer same resource. In this case, it’s better to use Content Negotiation so you can offer one URL that others can use to link to the resource.

One way to get yourself some link discipline is to adopt Linked Data and the RDF data model, which ”extends the linking structure of the Web to use URIs to name the relationship between things as well as the two ends of the link.” See also the Web Annotations and Linked Data & REST pattern.

Links can be expressed in standard formats

The standard way to represent links on the web is through HTML and in HTML, links are expressed in a variety of ways, via anchor tags, via image tags, the link tag and others. There are other standard ways to express links, but none as popular as HTML.

HTML

In HTML, links can be expressed via the <a> element, for expressing a hyperlink in text, and the <link> element, for expressing a link to a resource associated with the page.

<a> and <link> links can specify not only the URL of the link but also the relationship type of the link, as well as content-type and language for the resource that lies at the other end of the link. For example, a link type of rel=”next” indicates that a link points to the next page in a series of pages, or multi-page article. A link type of rel=”stylesheet” indicates that the link is to style-sheet to be applied to the current page. There are a standard set of link relationship types in the HTML spec. Here's an example from this very blog page, the link to this blogs Atom feed:



<link rel="alternate" type="application/atom+xml" title="Recent Entries (Atom)"     
   href="http://rollerweblogger.org/roller/feed/entries/atom" />

Atom

The Atom Syndication Format defines a <link> element, modeled on the one in HTML. Atom adds a length attribute, the size in bytes of the resource at the other end of the link. Atom defines some new links types, alternate, related, self and enclosure. Atom also allows new links to be added and a Atom link-type registry is maintained at IANA.org. Here’s an example link from the Atom comments feed for this blog:



<link rel="alternate" type="text/html" href=
"http://rollerweblogger.org/roller/entry/apache_roller_5_0_rc3#comment-12941523" />

RDF

Another standard way to express links is RDF, using any of the RDF serializations: RDF/XML, Turtle, N3 and soon, there will be a W3C standard for RDF/JSON. Yes, there will be a standard way to express links in JSON and that's good news. For now, we're stuck with RDF/XML. In RDF/XML a link is expressed via the rdf:resource attribute, so for example a link from a Requirement to the user that created the requirement might look like this:



<dc:creator rdf:resource="https://localhost:9443/user/676" />

RDF (Wikipedia page) goes way beyond the couple dozen link attributes and relationship types provided by HTML and Atom. RDF provides ways to specify property values about any linked resource, and property values of each link. RDF also provides ways to define vocabularies of properties.

Wrapping up

It's time to wrap-up. For better or worse, I’ve written more than I expected to write and I’m nowhere near done with the topic of links. I hope I’ve covered the important parts. Comments are open so please correct me and make suggestions if you got some. This is the first pattern that I’ve written up, so I’m also interested in comments about the format, level of abstraction, value, etc. as well.

Next up: Common Navigation.

More than bloggy

Dave Johnson — Mon, 7 Mar 2011 06:00:00 +0000

I’ve been meaning to write on this topic for a some time and to explain how I’ve gone from being an advocate of RSS/Atom feeds, Atom Publishing Protocol and things bloggy to being a proponent of Linked Data (video), Semantic Web, RDF and other things that I previously considered to be nuisances. I've also got a new topic and blog series to announce, so here goes.

Once upon a time, I actually said “the web is bloggy” in conference presentations and without shame. It sounds silly and, for a blog server developer self-serving, but it’s true and it’s still true to this day. So much of what we do on the web can be made more useful via feeds. That’s because so many things can be usefully represented as a well formed log entry, i.e. a URL, title, date, description and a chunk of content. No matter whether your web application is Flickr, Twitter or IBM/Rational Team Concert, you can enable all sorts of interesting integrations and mashups by providing feeds.

Atom Publishing Protocol (APP) applied the feed concept to web APIs, using a feed to represent a collection of entries and allowing API callers to use HTTP to create, retrieve, update and delete entries. Entries could be anything of course. In the case of Google’s APP-based GData Protocol, entries are Calendar Events, Picasa Photo uploads or YouTube videos. In the case of the IBM/Lotus Connections API, entries are Forum Posts, Social Network Profiles, File Uploads and more.

Feeds only get you so far

I’m not going to argue that RSS is dead (or Atom) because I don't believe that, but the feeds approach only gets you so far. With feeds, we agree on a small set of common properties, e.g. URL, title, date, description and content. Not all resources on the web have those properties and many resources have a lot more. So in some cases applying Atom means forcing things to fit into the Atom model and in some cases it means inventing new properties for Atom, something that is supported by Atom format.

APIs only get you so far

I’m not going to argue that APP is dead or a failure either, but APP is an API approach and, for web integration, APIs only get you so far. It’s definitely a good thing for developers when a web site or application provides an API, but if you have to integrate a set of N web sites and each has it’s own API and (even if they’re all based on APP) you’re stuck doing N x N point-to-point integrations. APIs are not necessarily the best way, and certainly not the only way, to enable integrations on the web.

Linked Data

Linked Data (W3C page) is a different approach. Instead of forcing everything to fit the blog model, Linked Data gives us a way to define common vocabularies of properties about resources on the web and, most importantly, the links between them. Linked Data enables integration by allowing sites to weave their resources into the interlinked web of data that is the web.

Next: Web Integration Patterns

These days, what's important to me at work is integration and in my mind, Feeds, APIs and Linked Data are different “patterns” for web-based integrations. They can be used in complementary ways. Just as we have defined and cataloged Enterprise Integration Patterns, I think it will be useful to do the same for Web Integration Patterns. I know I'll learn something in the process. In my next posts, I'll expand on this concept and after that, I'll start cataloging, in an informal and bloggy way, the patterns that I'm familiar with. More later...

MarsEdit 3 and Roller 5

Dave Johnson — Wed, 5 May 2010 17:01:17 +0000

Mac-based weblog editor MarsEdit v3.0 has just been released by Red Sweater Software.

Because MarsEdit v3.0 supports the Atom Publishing Protocol (APP), it works with Apache Roller 5.0RC1's new and improved AtomPub support right out of the box. I'm writing this post in MarsEdit right now and publishing to Roller 5 via APP.

MarsEdit includes a rich text editor and supports image upload via drag-and-drop into the editor. You can edit a draft post locally or use Send to Blog to send the draft to the server for further editing before publish. You can specify multiple tags for your post and MarsEdit will send them to Roller as tags.

Generally, I prefer to edit my HTML by hand but for somebody who wants simplicity and a familiar Mac interface, MarsEdit v3.0 looks like a great choice. And the HTML it generates doesn't look too bad.

Here's a screenshot that shows what MarsEdit looks like when editing a post:

Here are the settings I'm using (URLs changed to protect the innocent).

MarsEdit is $39.95 and there's a 30-day free and fully-function trial version available too.

Apache Roller 5.0 RC1

Dave Johnson — Mon, 3 May 2010 08:39:13 +0000

It's been a while since the BETA (over 6 months) but we now have a release candidate for Apache Roller 5.0 available for testing. This site is running Apache Roller 5.0 RC1 right now, as you can see in the itty bitty screenshot below:

Here's a What's New in Roller 5.0 page that summarizes what has changed since 4.0. One thing I forgot to mention on that page was that Roller now uses ROME Propono 1.0 for AtomPub and Roller 5.0's AtomPub support has been successfully tested with MarsEdit and Windows Live Writer.

Trip report: Social Web Camp, Santa Clara, CA

Dave Johnson — Mon, 9 Nov 2009 10:07:19 +0000

(I just returned to work after vacation and a week of conferences in the SF bay area. Instead of posting my trip reports to the limited audience that reads my internal IBM blog, I'm going to post them here so that everybody can benefit from them.)

On Monday Nov. 2, I attended Social Web Camp at Sun's Santa Clara campus. There were about 40 people in attendance. The event was organized by Sun's Henry Story, an expert in semantic web technologies and inventor of the FOAF+SSL approach to implementing Social Networking features (relationship based privacy). Unfortunately, Henry was not able to attend the conference because he was detained by US immigration.

Social Web Camp, Santa Clara, CA
http://barcamp.org/SocialWebCamp-Santa-Clara
Sun's Santa Clara Campus - AKA the Agnews Insane Asylum
http://www.nps.gov/nr/travel/santaclara/agn.htm
FOAF+SSL distributed/open social networking
http://esw.w3.org/topic/foaf+ssl
Henry detained for 6 days, case dismissed in 30 seconds
http://twitter.com/bblfish/status/5509198135

During the camp, I lead a session on OpenSocial using my "What's up with OpenSocial" slides from BarCampRDU. Surprisingly, very few people were familiar with OpenSocial, so this was an introductory level discussion.

What's up with OpenSocial preso from BarCampRDU
http://docs.google.com/present/edit?id=0AWuMBlP1tnN6ZGcyY2ZuendfOThmcXMydjdmcQ&hl=en

I participated in a session on enterprise social networking and shared a little about we do with micro-blogging inside IBM, mentioning BlueTwit and the new features in Lotus Connections. A couple of folks from Boeing were present and described the home-grown social networking and micro-blogging system.

BlueTwit mentioned in Business Week
http://www.businessweek.com/magazine/content/08_22/b4086056643442.htm

John Panzer of Google pitched his new Salmon protocol, a distributed commenting system that allows comments made on items in downstream systems (e.g. aggregators, social networks, FriendFeed, etc.) to find their way back upstream to the source item. The protocol is based, in part, on AtomPub. Comments are signed and posted back upstream. Seems like this could be useful in both Lotus Connections river of news feature, Jazz-based products and Roller; so I'll going to track this one closely. It might be fun to try to implement Salmon for Roller.

Salmon: comments and annotations to swim upstream, spawn more commentary
http://www.salmon-protocol.org/

I missed a little of the conference because I had lunch with some of my former co-worker from Sun and I left a little early to return my vacation rental car and make my way to Oakland for ApacheCon US 2009. More about that later...

OAuth for ROME Propono

Dave Johnson — Tue, 24 Mar 2009 12:00:00 +0000

Yesterday I wrote about OAuth support in the upcoming Roller 5.0 release. Today I'm following up with a post about OAuth support in ROME Propono.

As you may remember, ROME Propono is a subproject of ROME, the Java-based RSS/Atom feed library. ROME Propono includes an AtomPub server library and an AtomPub client. I added OAuth support to the AtomPub client and in this post, I'll show how you can use it to post to the Roller 5.0-dev (i.e. the snapshot build that I made available yesterday).

ROME 1.0 and coming soon: ROME Propono 1.0

In case you haven't already heard, thanks to the recent hard work of Nick Lothian, ROME 1.0 is now available. You can find downloads at rome.dev.java.net and a list of changes in the Change Log there. To celebrate this momentous event, I'm planning on releasing ROME Propono 1.0 as well, and in preparation, I've made a release candidate available. The new Propono includes ROME 1.0 and support for OAuth. You can get it via the links below:

rome-propono-1.0RC1.tar.gz (2.0 mb)

rome-propono-1.0RC1.zip (3 mb)

Posting to Roller via AtomPub and OAuth

To use the Propono AtomPub client, you place the Propono jars in your Java VM classpath and then call the AtomClientFactory to get started, as described in the ROME Propono 1.0 Javadocs.

Below is a Groovy example that shows how to post a blog entry to Roller via AtomPub and OAuth. You can get the consumer key, secret and URLs you need to call your instance of Roller from the OAuth Credentials page in the Roller admin interface.


  import com.sun.syndication.propono.atom.client.*
  import com.sun.syndication.feed.atom.*

  def authStrategy = new OAuthStrategy(
    "roller",                               // username
    "55132608a2fb68816bcd3d1caeafc933",     // consumer key
    "bb420783-fdea-4270-ab83-36445c18c307", // consumer secret
    "HMAC-SHA1",                            // key type
    "http://blogs.example.com/roller-services/oauth/requestToken",
    "http://blogs.example.com/roller-services/oauth/authorize",
    "http://blogs.example.com/roller-services/oauth/accessToken")

  // get the AtomPub service
  def appService = AtomClientFactory.getAtomService(
    "http://blogs.example.com/roller-services/app", authStrategy)

  // find workspace of my blog
  def blog = appService.findWorkspace("Blogging Roller")

  // find collecton that will accept entries
  def entries = blog.findCollection(null, "application/atom+xml;type=entry")

  // create and post an entry
  def entry = entries.createEntry()
  entry.title = "TestPost"
  def content = new Content()
  content.setValue("This is a test post. w00t!")
  entry.setContent([content])
  entries.addEntry(entry)

If you have questions or feedback about ROME Propono 1.0 RC1, please post them to the ROME dev mail list and I'll do my best to respond there.

OAuth for AtomPub in Roller

Dave Johnson — Mon, 23 Mar 2009 12:00:00 +0000

Over the past month or so I've been adding OAuth support to just about every open source project that I can commit to. I added OAuth support to Roller so that you can now use OAuth to protect Roller's AtomPub server and other things. I also added OAuth support to ROME Propono's AtomPub client so you can now use Propono to post to Roller (more about that later). Here's a quick overview of how OAuth in Roller works.

NOTE that this post applies to Roller 5.0, which has not yet been officially released.

Setting up OAuth for AtomPub in Roller

If you want to use OAuth with AtomPub on your Roller site, go to the Server Admin page and find the Web Services section, enable AtomPub and specify 'oauth' as the authentication mechanism, like so:

Getting your OAuth key, secret and URLs

Once you've done the setup, you'll find an OAuth Credentials link on the Roller Main Menu page, which will lead you a page like the one below showing your OAuth consumer key & secret and, if you are a site admin user, the site-wide key & secret. Currently, there's only one set of site-wide credentials; I plan to fix that.

Of course, those aren't my real keys. You'll want to keep your OAuth keys secret as they can enable anybody to access your Roller account via AtomPub.

Want to try it yourself?

I mentioned that Roller 5.0 has not yet been released and that's true. There's still a lot of work to be done on 5.0, but that doesn't mean you can't get your hands on the code and binaries now. To make it easy, I've made an unofficial snapshot version of Roller 5.0-dev available for testing purposes only. It's what I'm running on my site. You can get it here in two flavors:

apache-roller-5.0-dev-20090321-SNAPSHPOT.tar.gz (31 mb)

apache-roller-5.0-dev-20090321-SNAPSHPOT.zip (31 mb)

The instructions in the old Roller 4.0 installation guide should work fine, so follow them to install and configure the 5.0-dev SNAPSHOT. Please send questions and feedback to either the Roller dev mail list and I'll do my best to respond there.

You'll also need an OAuth capable AtomPub client. More on that topic tomorrow...

Sidebar: What is OAuth and why should you care?

Dave Johnson — Mon, 23 Mar 2009 08:01:39 +0000

I'm going to be following up my OAuth everywhere! post, with several more OAuth related posts this week. So, just in case you are wondering "why is Dave going off on this cockamamie OAuth tangent?", I'll take some time now to explain a little about OAuth to help you understand.

OAuth is a emerging protocol that one web site can use to access your data on another website without asking you to reveal your username and password. For example, when the sinister BuddyNet9000(TM) Social Network site wants to access your GMail account so it can spam your "friends" on your behalf, you can use OAuth to give it access without telling it your username and password. Why risk your GMail security when all you want to do is spam some people? There are less snarky examples, but that one makes the point well, I think.

There's a good end-user oriented introduction on OAuth.net titled Beginner's Guide to OAuth: Protocol Workflow. OAuth is not that widely deployed yet, and is not perfect, but it is emerging and going the IETF standards route.

I'm interested in OAuth because it's part of the OpenSocial spec, used to authorize access to the OpenSocial REST API and to enable OpenSocial Gadgets to call out to OAuth protected resources. Also, because it's used to protect AtomPub-based services, including the Google Data APIs. I needed to learn about it for my Roller and SocialSite work and if you're going to be doing much OpenSocial work, you'll need to learn about it too.

Atom news: Apache Abdera graduates

Dave Johnson — Fri, 21 Nov 2008 15:54:48 +0000

Congratulations to the Apache Abdera team, who've just graduated to full Apache top level project status. The don't have the new site at abdera.apache.org up yet and they're still not quite at 1.0 yet, but this is a major milestone. They've got the best Atom format and protocol toolkit around, in my opinion.

via Garett and James.

Shindig/Java internals diagram updated

Dave Johnson — Tue, 23 Sep 2008 16:09:52 +0000

A lot has changed since I did my first and even my second "how does Shindig/Java work" diagram. Believe it or not, there are now two separate web services protocols in OpenSocial and thus in Shindig. I'll explain that and then I'll share my updated diagram and synopsis of Shindig/Java internals.

NOTE: this post covers the social API implementation only and not the Gadget server portions of Shindig.

Here's what happened. There was a long discussion on the OpenSocial spec mailing list about the merits of REST vs. RPC for the OpenSocial web services APIs (e.g. here and here). I'm not going to characterize the two sides as the JavaScripty Gadgeteers and the XML-smokin' RESTafarians because that would be just plain silly. Long story short, neither side really "won" and so the latest rev 0.8.1 of OpenSocial includes two separate web services protocols:

The OpenSocial REST API, which is based on AtomPub but with support for XML and JSON formats in addition to Atom format XML. There is no support for batching of operations. (There was a proposal for RESTful batching, but it did not gain consensus.)
The OpenSocial JSON-RPC API where methods are called by HTTP POSTing JSON data and there is full support for batching of operations.

Seems a pity to have two separate protocols that serve essentially the same purpose, but thankfully there are a lot of similarities. For example, the JSON-RPC protocol methods are GET, POST, PUT and DELETE. And the JSON format used in the JSON-RPC protocol matches the one in the REST API. That makes things a little easier for implementers and if you use Shindig as the basis for your social network's OpenSocial implementation, it's even easier -- you implement one set of interfaces and you get support for both REST and JSON-RPC. Next, I'll explain how that works with my updated diagram:

And I'll explain by walking through the processing of one request; here's the walk-through (new stuff is highlighted in yellow:

1... A request enters Shindig via either the DataServiceServlet at /social/rest or the JsonRpcServlet at /social/rpc, which has a map of DataRequestHandlers (which it got from the HandlerProvider) keyed by the route that each handles. It's also got a pair of bean converters, which will come into play later when we need to convert outgoing POJOs to XML or JSON representation.

2... The Servlet creates a RequestItem, which parses the request for easy access later. The request item also has a pair of converters which can be used to convert incoming XML or JSON data into Java POJOs.

There are two different request items, one for REST RestfulRequestItem and one for RPC RpcRequestItem. The RESTful request item parses the incoming URL for parameters and treats data from a POST or PUT as typed data, to be automatically converted from JSON, XML or Atom into a Java POJO object from the SPI.

In the RPC case, everything is a POST and the request item grabs its parameters and the typed payload from the JSON object that was posted to the server.

3... The Servlet calls the appropriate handlers. If the request is a single request, then the Servlet looks up a DataRequestHandler based on the request's "route" (i.e. the first segment of URL's pathinfo). The Servlet calls the selected handler, hands it a request item. If the request is a batch request then the Servlet does the same as above, but in a loop collecting request items.

4... One of Shindig's three request handlers then handles the request and returns a ResponseItem or (plural) items containing the Plain Old Java Objects (POJOs) to be returned to the called. This is the point where incoming XML or JSON data is de-serialized to POJO form by a call to requestItem.getTypedParameter(). Shinding provides three DataRequestHandlers:

PersonHandler: returns Person objects with detailed profile information
ActivtyHandler: returns Activities of people or group, allows activity creation
AppDataHandler: returns Gadget data, allows Gadets to store data

NOTE: If want to add your own REST/RPC APIs to extend Shindig, as we are doing in SocialSite, you can do it by hooking in your own handlers. Use Guice dependency injection to hook in your own custom HandlerProvider, one that returns your own custom handlers.

5... The Shindig handlers call the Shindig Service Provider (SPI), which is defined by a set of interfaces with methods that return ResponseItems. There is a set of model objects, aka POJOS, shown in green that represent the different data types that can be returned by the REST or RPC APIs. The service implementations return these POJO objects and expect the Shindig infrastructure to automatically map POJO to either JSON or XML as appropriate.

PersonService: returns Person objects with detailed profile information
ActivtyService: returns Activities of people or group, allows activity creation
AppDataService: returns Gadget data, allows Gadgets to store data

NOTE: the SPI is where you hook in to Shindig if you want to expose your application's Social Graph data via the standard OpenSocial REST or RPC API. You implement these interfaces with code that calls your back-end to create, retrieve update and delete data. And you hook your implementation via Guice.

6... The handler returns a ResponseItem, which wraps one or a collection of POJOs. The Servlet may then write that response out or, in the batch case, continue to call handlers and collect more ResponseItems.

7...Servlet converts/serializes and returns ResponseItems. In the REST API case, once the handler, or handlers in the batch case, returns the response item(s), the DataServiceServlet calls the appropriate converter to serialize the item(s) to either JSON or XML format depending on what was specified in the 'format' request parameter.

And that's that...

re: delicious.com Blog Posting tool

Dave Johnson — Mon, 22 Sep 2008 17:56:32 +0000

Oh and by the way, I have not given up on that Delicious.com Blog Posting tool that I wrote about in August. I've got the feed fetching, entry composing parts done now and I'm currently working on the blog posting code. I hope to have something ready to blog about this week.

re: How the Shindig REST API works

Dave Johnson — Mon, 11 Aug 2008 17:02:15 +0000

Here's a diagram I worked up over the weekend to explain Shindig REST API internals to my team mates. See the Project SocialSite blog for the full story.

Latest Links: Friday March 7, 2008

Dave Johnson — Fri, 7 Mar 2008 14:00:05 +0000

snellspace.com: Contact!
"So Google announced it?s Contacts API? based on Atompub of course"
netzooid: Writing Your First AtomPub Service with Abdera
"This shows the much simplified server code base in action, so beware - this requires the latest trunk/ code. 0.4.0 should be out soon though"
Astoria: AtomPub support in the ADO.NET
"We have been looking for the last few months at adding first-class support for AtomPub to Project Astoria"
Marc Hadley's Blog: Authentication in Jersey
"Actions on some resources require authentication and I need access to the name of the authenticated user in the resource method"
The Aquarium: Jersey 0.6 released
"the Jersey client API, enhanced JSON suport, and better integration of Jersey with IoC containers"
Carrot2 - Open Source Search Results Clustering Engine
"Carrot2 is an Open Source Search Results Clustering Engine. It can automatically organize (cluster) search results into thematic categorie"
MySQL Forums: Partitioning
The official discussion forum for those interested in or experimenting with MySQL Partitioning technology
Partha's Blog: MySQL Table Partitioning
Nice series of posts on table partitioning in MySQL 5.1
Simon Phipps: The Adoption-Led Market
"emerging approach which is rapidly spreading for smaller software projects and in my view is the future of all software acquisition"
Will Acquia ruin Drupal? | Open Source | ZDNet.com
"Acquia, a commercial version with all the bells and whistles, including venture capital partners, whoâ€™ve put in $7 million."
JPost.com | BlogCentral
Jerusalem Post is blogging with Roller!
triangletweetup wiki
Triangle Tweetup Attendance & information

AtomPub in OpenSocial 0.7

Dave Johnson — Tue, 5 Feb 2008 11:38:30 +0000

I missed this one in my social networking API link-fest yesterday: Google announced version 0.7 of the OpenSocial API, some of the data APIs are outlined in the spec and they're still using AtomPub protocol (just like GData).

I had heard there was some push-back against AtomPub, but I really don't know what is going on because there is no transparency at all in the specification development process. So, who knows, but I really don't think they have time to invent an all new protocol. In fact, they'd better wrap things up tout de suite because Google's planning to go live with OpenSocial on Orkut during the last week of February.

Abdera AtomPub server refactoring

Dave Johnson — Mon, 28 Jan 2008 09:05:45 +0000

I've got to carve out some time ASAP to take a close look at this. The code is in Abdera SVN and there's <a href= "http://cwiki.apache.org/confluence/download/attachments/69763/abderaserverguide.pdf"> 20-minute implementation guide (PDF) too:

James Snell: Dan Diephouse and I have been spending the last week refactoring the Abdera server framework with the goal of making is less complicated, easier, and generally better.

Abdera rocks on

Dave Johnson — Fri, 11 Jan 2008 18:18:08 +0000

There have been some interetsing Atom items recently on James Snell's blog. There was a link to a nice IBM DeveloperWorks article on using Abdera to write Atom feeds to JSON. (I was kinda hoping for an XSL/T, but not matter how you do it, it's a definitely feature that belongs in Abdera.) And there's a good quote from Adrian Sutton's blog post about the Atom features in IBM's Roller and Abdera based Lotus Connections product. And most recently, James linked to the new Google Feed Server project: an Abdera based AtomPub server from Google. All good stuff.

Gotta say, Abdera's looking better and better. It's got the features (IRI support, encrytion, pluggable auth, STAX parsing, etc.) and it's got Dan and appears to have some good momentum going. At this rate, I'm not sure how much more work I'll be putting into ROME Propono. If somebody were to, just for example, contribute an Abdera based AtomPub implementation to Roller, I might have to stop entirely.

Latest Links: Feedsync, AtomPub for SOA, OpenSocial and more

Dave Johnson — Thu, 6 Dec 2007 14:00:10 +0000

snellspace.com: Sync!
"Within the course of implementing several Atompub servers, the issue of â€œfeed synchronizationâ€ has come up repeatedly"
Paul Fremantle's Blog: A new kind of (SOA) Registry
"as we looked at the REST space, we kept noticing how close the [AtomPub] is to our needs"

OpenSocial - Berlin Web 2.0 Expo
Google API evangelist Pat Chanezon's OpenSocial presentation
opensocket - Run OpenSocial Gadgets in Facebook
An OpenSocial container written as a Facebook application.
Ruby on Rails: OpenSocial container plugin 0.0.1
"This is a very early version, but it is under very active development "

IBM's Carol Jones on Web 2.0 Research and Collaborative Software
Redmonk video discussion of Lotus Connections, Dogear, internal/private vs. external bookmarking
Wayne Horkan's weblog eclectic: Weblog language translator
With Roller specific functionality. Based on JavaScript and Google translation API
ZDNet.com: Social nets and identity fragmentation
FaberNovel Consulting has mapped out some trends in social networking and digital identity"
Postgres at Hi5: June 2007 user group preso
How unique features of PostgreSQL helped Hi5 scale (PDF presentation)
Scaling Java and PostgreSQL with Hyperic
Another perspective on PostgreSQL scalability at Hi5 (PDF presentation)
Skrentablog: Scaling Facebook, Hi5 with memcached
"discussion of high volume [sites] using memcached as a critical scaling tool"

More on AtomPub and Windows Live Writer

Dave Johnson — Sat, 20 Oct 2007 17:08:19 +0000

Joe Cheng posted another entry in his series explaining the details of AtomPub support in Windows Live Writer (WLM), titled WLW+AtomPub, Part 2: Authentication.

Wondering what WLM looks like? Travelin' Librarian has a nice set of screen-shots of WLM on Flickr including shots of the installation process, HTML mode, preview mode and more. Looks pretty sweet.

Latest links: AtomPub news round-up edition

Dave Johnson — Fri, 12 Oct 2007 12:31:13 +0000

I've been in crunch-mode working on a new project, but I've been trying to keep an eye on what's going on the world of Atom Publishing Protocol or AtomPub as the cool kids call it. Here's a wrap-up of some of the AtomPub news I've picked up on the past month or so.

Specifications

The big news is, of course, that AtomPub has been granted an RFC number RFC-5023 and is now an IETF "proposed standard" like Atom format (RFC-4287). The folks at Ricoh have provided a Japanese translation.

Extensions to AtomPub are under development and you can find a good list of them at the XML Cover Pages page for Atom. One I find interesting is James Snell's AtomPub Feature Discovery spec, which is designed to help AtomPub clients determine what features are supported and required by servers. The features spec is controversial and has sparked a lot of good discussion including, Brian Smith's email Atom Weblog Publishers Guide and Sergey Beryozkin and Dan Diephouse's discussion of AtomPub and WS-Policy

Server implementations

More big news to report here: the new Wordpress 2.3 release provides full support for AtomPub. Sam Ruby blogged about it in Wordpress 2.3 loves AtomPub and the Wordpress 2.3 AtomPub docs provide a good summary and cover some limitations. Yesterday, Sam posted Wordpress vigilance and plans. He wants to get Wordpress to score a perfect 0 errors and 0 warnings on the APE tests, which means among other things preserving foreign markup.

New releases of Apache Roller have also been updated for the final AtomPub spec. The upcoming Roller 3.1.1 and Roller 4.0 releases include AtomPub support. Both releases are up for vote now, so they should be out Real Soon Now. And I'm working on adding AtomPub support for comments for Roller 4.1, building on top of the Atom Threading Extension (RFC-4685).

I've been googling and browsing the SixApart site, but I can't figure out if Movable Type 4.0 supports the final AtomPub spec. Anybody know?

And Google has added another AtomPub based API. Read about it on Bill de hÃ“ra's blog YouTube via GData and on the YouTube Developer API blog: New YouTube API Released into the Wild.

Client implementations

In Stick a fork in it Joe Cheng writes "The Windows Live Writer team is still on track to deliver AtomPub support in the next version, which I am looking forward to immensely. Itâ€™s definitely an exciting time to be in the blogging tools space!" Based on what I saw at the last face-to-face AtomPub interop, it looks like Microsoft may have the best AtomPub-based blog client around. I wonder when MarsEdit and Ecto will get on board with AtomPub.

Toolkits and programming libraries

I already blogged about the Propono 0.6, a Java-based client and server library for AtomPub, which has been updated for final spec. Since then the Apace Abdera project has released Apache Abdera (incubating) 0.3 release is available with a long list of improvements and new features. There are also a couple of usage notes from James Snell. Also on the topic of Abdera, Dan Diephouse has done some work to make Spring and Abdera work well together.

The Perl AtomPub::Client at CPAN has updated for final AtomPub too.

That's all I've got for now. Did I miss any important AtomPub news?