Miles to go …

In my previous Web 2.0-related blogs, I talked about What is Web 2.0 ?, What is AJAX ? and AJAX: jMaki Framework. Switching gears, this blog will talk about another technology that enable the principles of Web 2.0, i.e. RSS/Atom.

Lets begin with English meaning of the terms "syndication" and "aggregator" first. 

Syndication means:  "The act of syndicating a news feature by publishing it in multiple newspapers etc simultaneously"

Aggregator means: "An online feed reader, generally used for RSS or Atom feeds to keep track of updates to blogs, news sources, and other websites"

Any content over the web, that changes frequently or at irregular intervals, needs a mechanism to inform it’s audience about the updates. RSS and Atom are XML formats designed to generate "syndicated feeds" to publish such frequently updated content. Each feed contain details about the title, a short summary, link to the detailed entry and metadata. This content could be either the entire website or, more interestingly, just a specific section of the website targeted towards an audience. The audience of the content uses "feed aggregator" to fetch the feeds, organize the results, and read the contents. is the standard way to identify syndicated content. The XML format defined by RSS and Atom is really simple leading to it’s exponential growth (also 1, 2, 3)  in the recent years.

A detailed history of how RSS evolved over multiple versions, in the past 7 years, is available here. A concise history, with a tabular difference of different RSS versions, is available here. RSS 2.0 is the most feature rich version and stands for "Really Simple Syndication". It defines an XML format to publish frequently updated content of your website. An non technical introduction to RSS explains how RSS feed is generated. For example, an RSS feed to my blog is given below. This feed cannot be directly viewed in the browser (both Firefox 1.5.x+ or IE6) as they both have a default stylesheet that displays it nicely formatted in HTML. The XML data (as shown below) behind the feed can be viewed using "View Source" option on the page. 

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="http://blogs.sun.com/roller-ui/styles/rss.xsl" media="screen"?>
<rss version="2.0"
 xmlns:dc="http://purl.org/dc/elements/1.1/"
 xmlns:atom="http://www.w3.org/2005/Atom" >
<channel>
 <title>Miles to go ...</title>
 <link>http://blogs.sun.com/arungupta/</link>
 <atom:link rel="self" type="application/rss+xml" href="$url.feed.entries.rss($model.categoryPath, $model.excerpts)" />
 <description>Arun Gupta&apos;s Weblog</description>
 <language>en-us</language>
 <copyright>Copyright 2006</copyright>
 <lastBuildDate>Tue, 19 Dec 2006 11:10:03 -0800</lastBuildDate>
 <generator>Apache Roller (incubating) 3.2-dev(20061208101134:ag92114)</generator>
 <item>
 <guid isPermaLink="true">http://blogs.sun.com/arungupta/entry/running_san_francisco_marathon_2007</guid>
 <title>Running San Francisco Marathon 2007</title>
 <dc:creator>Arun Gupta</dc:creator>
 <link>http://blogs.sun.com/arungupta/entry/running_san_francisco_marathon_2007</link>
<pubDate>Tue, 19 Dec 2006 10:34:09 -0800</pubDate>
 <category>Running</category>
 <category>marathon</category>
 <category>running</category>
<description>As if one marathon was not

During the history of RSS, there were multiple versions (0.90, 0.91, 0.92, 0.93, 1.0, and 2.0) all of which had shortcomings and multiple incompatibilties. To overcome the political (different camps own these versions and claiming to be correct) and technical difficulties, Atom syndication format was published as an IETF "proposed standard" (IETF terminlogy defined by RFC 2026) in RFC 2487.  Like RSS, Atom also defines an XML format to public frequently updated content of your website. For example, an Atom feed to my blog (viewed using "View Source" option) looks like:

<?xml version="1.0" encoding='utf-8'?>
<?xml-stylesheet type="text/xsl" href="http://blogs.sun.com/roller-ui/styles/atom.xsl" media="screen"?><feed xmlns="http://www.w3.org/2005/Atom">
 <title type="html">Miles to go ...</title>
 <subtitle type="html">Arun Gupta&apos;s Weblog</subtitle>
 <id>http://blogs.sun.com/arungupta/feed/entries/atom</id>
 <link rel="self" type="application/atom+xml" href="$url.feed.entries.atom($model.categoryPath, $model.excerpts)" />
 <link rel="alternate" type="text/html" href="http://blogs.sun.com/arungupta/" />
 <updated>2006-12-19T11:10:03-08:00</updated>
 <generator uri="http://rollerweblogger.org" version="3.2-dev(20061208101134:ag92114)">Apache Roller (incubating)</generator>
 <entry>
 <id>http://blogs.sun.com/arungupta/entry/running_san_francisco_marathon_2007</id>
 <title type="html">Running San Francisco Marathon 2007</title>
 <author><name>Arun Gupta</name></author>
 <link rel="alternate" type="text/html" href="http://blogs.sun.com/arungupta/entry/running_san_francisco_marathon_2007"/>
 <published>2006-12-19T10:34:09-08:00</published>
 <updated>2006-12-19T10:34:09-08:00</updated>
 <category term="/Running" label="Running" />
 <category term="marathon" scheme="http://rollerweblogger.org/ns/tags/" />
 <category term="running" scheme="http://rollerweblogger.org/ns/tags/" />
 <content type="html">As if one marathon was not

A comprehensive comparison of Atom 1.0 and RSS 2.0 highlights the differences between two formats. The key difference between the two formats is given below:

• The biggest complaint about RSS is that the format is "lossy" and does not preserve the type of data. Atom maintains the type and therefore allows wider variety of payloads.
• RSS 2.0 specification is copyrighted and frozen. Atom 1.0 is published as a "proposed standard" in IETF and is extensible.
• RSS 2.0 feeds cannot be auto-discovered. Atom feeds can be auto-discovered using IANA-registered MIME type application/atom+xml.
• RSS 2.0 supports no schema. Atom 1.0 includes RelaxNG schema that allows checking for validity of data.

As evident, Atom has some significant advantages over RSS 2.0 and is now more commonly used. For example weblogs.java.net (based on Moveable Type) and blogs.sun.com (based on Roller) both offer Atom 1.0 feeds. Bloglines, the most popular web-based aggregator, supports all the RSS and Atom formats. A known list of Atom 1.0 consumers and  Atom 1.0 Feeds shows the growing adoption of Atom 1.0.

Blogging, news content syndication, podcasting are the most common usage of syndication/aggregation. 

In my next blog, I’ll talk about Rome and how it makes it easy to work in Java with most syndication formats.

_{Technorati: Blogging Syndication Aggregation Feeds RSS Atom Web 2.0 Technology}

I’ve always been wondering the meaning of dots in del.icio.us. The wikipedia entry explains it well:

The del.icio.us domain name is a popular example of a domain hack, an unconventional combination of letters to form a common word or phrase. del.icio.us, though not the first domain of this nature, is the best-known and most frequently accessed domain hack, and the Yahoo! acquisition is the highest-profile acquisition of a domain in this category. However, delicious.com also redirects to the del.icio.us website.

_{Technorati: del.icio.us wikipedia}

blogs.sun.com (the blogosphere of all Sun employees) allows each blog entry to be directly posted to a social bookmarking website, for example submit them to del.icio.us, dig them on Digg, discuss on Slashdot and other Web 2.0 sites. And it enables that by providing additional macros that can be specified in the page template. Once the macros are saved to the page template and the blog page is refreshed, all entries are updated with an icon and a link for the website. For example, going forward all my blog entries here will have an icon and link to del.icio.us (social bookmarking), furl (personal web archive), simpy (social bookmarking), slashdot (news for nerds), technorati (blog search engine), and digg (community-based popularity website). If you are a Sun employee, send me an email and I’ll send you the instructions to include these icons in your blog. 

Yet another way Sun has embraced Web 2.0.

_{Technorati: Web 2.0 Roller Social bookmarking}

In a previous blog, I talked about AJAX. You can read about different AJAX design strategies, their pros/cons and when to use. This blog introduces you to jMaki.

Originally the project, jMaki, started as a wrapper for existing AJAX frameworks giving access to the JavaScript widgets from JSP pages or JSF components. And so the name, jMaki, where "j" is for JavaScript and "maki" is a Japanese word to "wrap" was sufficient. Even the logo for jMaki, a "j" as the cursive foot of the Chinese character meaning wrapper, was self describing. In that role, jMaki provides access to widgets from existing AJAX frameworks such as Dojo, Scriptaculous, Google Web Toolkit and Yahoo UI Library. A jMaki wrapper over several components from a variety of frameworks can be seen in this widget gallery. A more complete collection of widgets, organized by their framework, is available here. In the past few weeks, the project has transformed into a complete AJAX framework that provides a lightweight model for creating JavaScript centric AJAX-enabled web applications using Java (Java Server Pages and Java Server Faces), PHP 5.x, and Phobos (another of Sun’s Web 2.0 offering, more on this later).

jMaki framework, as explained earlier, decouples the presentation logic and underlying data using Widget Model, Client Services, Layouts and Client Runtime on the presentation layer (a.k.a. Client Side Components) and Server Side Runtime and XmlHttpProxy on the data layer (a.k.a. Server Side Components). The original intent of the project, wrapper for existing AJAX frameworks, is now served by the Widget Model.

After reading all the details, it’s time to try some code. Before you begin, I recommend watching this screen cast that introduces you to jMaki and walks you through the steps of developing a web application using jMaki plug-in in NetBeans. Using the screen cast, here are the steps that I followed:

1. Download NetBeans 5.5.
2. Download the NetBeans Ajax Update Center Module. I preferred the update center module over the jMaki plug-in NBM file (NetBeans module) as that allows me to download any related goodies (such as Phobos plugin) as well.
3. Install the downloaded plug-in following the instructions. The updated AJAX Update Center module screen shot is available here.
4. Create the web application following the steps in screen cast. 
5. NetBeans 5.5 comes pre-bundled with Apache Tomcat  5.5.17. Go to the "Runtime" tab of NetBeans IDE (default short cut is Ctrl + 5), select the "Bundled Tomcat (5.5.17)", right click and select "Start" to start the Tomcat.
6. Just for fun, I added the SuDoKu widget.
7. Once the application is deployed (in step 4) then it can be viewed at http://localhost:8084/WebApplication1 (8084 is the default port, WebApplication1 is context root of your application).

And, with these steps, I could develop a simple rich internet application in few minutes. Once all the configuration is setup, it would take less than a minute to add a pre-built jMaki widget into your web application.  The beauty of using JavaScript is that once the web application is deployed, adding new widgets to the page is drag-drop-save-refresh cycle, there is no separate deployment cycle.

Sang Shin (of JavaPassion.com fame) has created a great hands on lab that walks you through the basics of using jMaki widgets. In a later blog, I plan to talk about how to create a jMaki widget from scratch and wrap a widget from one of the existing toolkits.

_{Technorati: AJAX Sun Web 2.0 jMaki}

This is a follow up blog from here. It provides a brief description of the most prominent technology, AJAX, that enable the principles of Web 2.0.

AJAX stands for Asynchronous JavaScript and XML. This term was first introduced by Jesse James Garrett in February 2005. It is a set of technologies used to develop interactive web applications without requiring a complete page refresh. This is achieved by decoupling user’s interaction with the web application and the web application’s interaction with the server. The presentation control logic is embedded as JavaScript code snippets in the web page and the bulk of data is kept on the server. Any request from user to the web application that does not require a round trip to the server, for example data validation and displaying a different view of the pre-loaded data, is handled by this code. If data needs to be fetched from the server then this intermediate code makes an asynchronous request to the server without any interruption of user’s interaction with the application. This allows a clear separation between presentation logic and the underlying data.

AJAX achieves this using the combination of following set of technologies:

• XHTML and CSS for presentation
• DOM for accessing parts of the page that needs to be refreshed
• XMLHttpRequest for asynchronous exchange with the server
• XML, Text or HTML as the format for data exchange
• JavaScript to bind all of these pieces together.

There are several Ajax frameworks available that combines all these technologies together and ease the rapid development of Ajax-based applications. These frameworks offer JavaScript functions on the client-side to send request to the server and processes the requests, searches for the data and transmits them to the browser on the server-side. All of this done by hiding the differences between different browser and JavaScript runtime environments. Ajaxian.com has a survey of the most popular AJAX frameworks. These frameworks are getting richer and providing a comprehensive set of libraries ranging from DOM manipulation to animation framework to complicated layout widgets. However if there is a need to write your own custom widget then you can consider following the JavaScript recommendations for AJAX component writers. AJAX with the Java Platform explains the anatomy of an AJAX interaction in detail and has other useful resources on AJAX.

AJAX enables rich internet applications and is one of the most prominent technology to enable principles of Web 2.0. Read how Gmail, Google Suggest and Google Maps use AJAX to provide a richer, faster and more usable interaction. In my next blog entry, I’ll talk about jMaki and my experience of developing a Web application using the recently released jMaki 1.0 beta.

_{Technorati: AJAX Sun Web 2.0}