Blogging Roller

Upgraded to Roller 6.1.1

Dave Johnson — Sat, 30 Apr 2022 20:09:11 +0000

A note about this site: I just upgraded rollerweblogger.org to run the recently released Roller 6.1.1, and Java 17. There was one snag. This site uses the Roller-JSPWiki plugin and old Lucene dependency in that plugin prevented Tomcat from loading Roller. It took me a couple of hours to figure out how to upgrade the plugin to use the latest version of JSPWiki. That fixed it.

Building an Open Source J2EE Weblogger

Dave Johnson — Sun, 17 Apr 2022 16:42:50 +0000

I wrote this article for O'Reilly's OnJava.com over twenty years ago and it was published on April 17, 2002. Roller would not become Apache Roller until about five years later. Publishing this article changed my life and set my career on a new trajectory. I can't find it online anymore so to celebrate this anniversay, i'm going to publish it here on Roller.

As a Java developer, you should be aware of the tremendous wealth of open source development software that is available for your use -- even if you have no desire to release any of your own software as open source. In this article, I will introduce you to some of the most useful open source Java development tools by showing you how I used these tools to develop a complete database-driven Web application called Roller.

Roller fits into the relatively new category of software called webloggers: applications that make it easy for you to maintain a weblog, also known as a blog -- a public diary where you link to recent reading on the Web and comment on items of interest to you.

The Roller Web application allows you to maintain a Web site that consists of a weblog, an organized collection of favorite Web bookmarks, and a collection of favorite news feeds. You can define Web pages to display your weblog, bookmarks, and news feeds. By editing the HTML templates that define these pages, you have almost total control over the layout and appearance of these pages. Most importantly, you can do all of this without leaving the Roller Web application -- no programming is required.

I used over a dozen open source development tools to develop Roller, the most useful of which are listed in Table 1; however, this article focuses on just four tools: the XDoclet code generator, the Castor persistence framework, the Struts Servlet/JSP framework, and the Velocity code-generation engine. In this article I will describe the Roller application, its architecture, and specifically how I used XDoclet, Castor, Struts, and Velocity in its development.

Table 1: Open source tools used in Roller Development

Name	Description	Developer	Type of License*
Castor	Persistence framework	Exolab	Similar to BSD license
HSQL	Small but powerful Java database	Thomas Meuller	Similar to BSD license
Jakarta Ant	XML-driven Java build system	Apache	Apache Public License
Jakarta Commons	Collections, utilities	Apache	Apache Public License
Jakarta Struts	Servlet/JSP framework	Apache	Apache Public License
Jakarta Tomcat	Servlet/JSP Server	Apache	Apache Public License
Jakarta Velocity	Template-driven code generator	Apache	Apache Public License
Netbeans	Integrated Dev. Environment		Sun Public License
Xerces	XML parser	Apache	Apache Public License
XDoclet	Code generator	Dreambean	Similar to MIT License

* For more information on open source licenses see opensource.org

The Roller Application

Roller does not support all of the features of commercial weblogging software (such as Userland's Radio or Pyra Labs' Blogger products), but Roller does support what I consider the essential weblogging features. With Roller you can:

Maintain a weblog, with user-defined categories. You can write new weblog entries and edit entries that have already been posted. You can define a set of weblog categories and can assign weblog entries to different categories. This allows you to maintain several different weblogs, each covering a different topic.
Publish your weblog as an RSS news feed. Roller makes your weblog available as a standard Rich Site Summary (RSS) news feed so that readers can subscribe to and read your weblog without visiting your Roller site.
Maintain a collection of favorite bookmarks, organized by bookmark folders. You can define new bookmark folders and can add, delete, and edit the bookmarks within these folders. You can then display these bookmarks on one or more of your Roller site's pages. This allows you to do blogrolling -- displaying links to your favorite weblogs.
Maintain a collection of favorite RSS news feeds. This allows you to display headlines with links to news stories from your favorite news sources or weblogs.
Define a set of Web pages to display your weblog, bookmarks, and news feeds. Pages are defined using HTML templates with embedded macros for each type of data. For example, there is a $Bookmarks macro that will draw a portion of your bookmark collection on a Web page and a $WeblogCalendar macro that will draw a calendar view of your past weblog entries. These templates allow you almost complete control over the layout and look-and-feel of your Web pages.

There are two types of Roller users: readers and editors. Readers are simply anonymous visitors to the Roller Web site. Editors have user accounts and must log in by providing a user name and password. Editors have the ability to edit their weblog entries, bookmarks, newsfeeds, and page templates.

Figure 1 illustrates the Roller application by showing the Roller Web page navigation tree. The boxes represent Web pages and the arrows represent links between pages. The gray pages are the public pages that any visitor may access, the yellow pages are the login pages, and the red pages are the pages that only editors can access.

Figure 1: Roller Web Pages

Roller Architecture

Internally, Roller is divided into a presentation tier and a business tier, as recommended in Sun's J2EE Pattern Catalog. The presentation tier is responsible for Roller's user interface, and the business tier is responsible for Roller's application logic and the persistence of application data. Figure 2 provides an overview of the Roller architecture.

Figure 2: Roller Architecture

The presentation tier is implemented using the Model-View-Controller (MVC) pattern and the Struts MVC framework. The Model is an abstraction of the application logic and application data and is represented by a set of interfaces defined in the org.roller.model package. The View is implemented using Servlets, JSP pages, and Velocity page templates. The Controller is Struts, which is responsible for receiving incoming requests and dispatching them to the View. The implementation of the presentation tier is further discussed in the sections on Struts and Velocity.

The business tier implements the interfaces in the org.roller.model package, using the Castor JDO persistence framework. The business tier exchanges data with the presentation tier in the form of simple, lightweight JavaBeans known as Value Objects. Value Objects are yet another of the Sun J2EE patterns. Each Value Object maps to a table in the Roller database.

Figure 3 shows the Roller Value Objects, their properties, and the relationships between them. Each editor is represented by a User object. Each User has a Website object, which represents the editor's Web site and which has weblog entries, bookmark folders, newsfeeds, and page templates. The Website object also specifies the default page template of the Web site and which page template is used for rendering a day of weblog entries.

Figure 3: Roller Value Objects

The business tier uses Castor JDO to store and retrieve Value Objects to and from a JDBC-accessible database. Castor JDO is part of the larger Castor data-binding framework, which according to the Castor Web site is "the shortest path between Java objects, XML documents, SQL databases, and LDAP."

As a persistence framework, Castor JDO is similar to commercial object-relational mappers such as TopLink and Cocobase. Castor JDO fulfills a role similar to that of Sun's Java Data Objects, but Castor JDO is not an implementation of Sun's JDO specification (JSR-000012). Castor JDO allows you to define a mapping between Java classes and tables in a relational database. You can then issue queries using Castor's own Object Query Language (OQL) and receive the results as collections of Java objects.

Before you can use Castor JDO, you must provide a mapping file -- an XML file that maps each class to a database table and each class property to a field within a database table. Below is a portion of Roller's mapping file.

<mapping> 
<class name=org.roller.model.BookmarkData" identity="id"
    access="shared" key-generator="UUID" auto-complete="false">
    <map-to table="bookmark"/> 
    <cache-type type="count-limited"/>
    <field name="folderId" type="java.lang.String"></field>
    <field name="id" type="java.lang.String"></field>
    <field name="image" type="java.lang.String"></field>
    <field name="name" type="java.lang.String"></field>
    <field name="priority" type="java.lang.Integer"></field>
    <field name="url" type="java.lang.String"></field>
</class>
...
</mapping>

Once you provide Castor with a mapping file, retrieving a collection of objects from the database can be as simple as the code snippet shown below:

// Construct a new query and bind its parameters
String query = "SELECT p FROM BookmarkData p WHERE websiteId=$";
OQLQuery oql = db.getOQLQuery( query );
oql.bind( websiteId );

// Retrieve results and print each one
QueryResults results = oql.execute();
while ( results.hasMore() ) {
   BookmarkData bookmark = (BookmarkData)results.next();
   System.out.println( bookmark.toString() );
}

XDoclet

XDoclet is a code generator that is implemented as a Javadoc extension, a Doclet. To use XDoclet, you place special Javadoc tags in your Java source code. Based on these tags, XDoclet can generate additional Java code that supports your classes, mapping files that map your classes to database tables, and deployment descriptors that assist in deploying your classes.

XDoclet started out its life as EJBDoclet, a tool that allows you to implement an Enterprise JavaBean by writing just one source code file. Now, the XDoclet product includes two Doclets: EJBDoclet and WebDoclet. EJBDoclet is for generating EJB classes, value objects, and database mappings. WebDoclet is for generating all sorts of Servlet Web Application deployment descriptors, including web.xml files, Tag Library Descriptors, and Struts configuration files.

The Roller build process uses both EJBDoclet and WebDoclet, as shown in Figure 4. In Step 1, EJBDoclet is used to process a set of abstract classes of type javax.ejb.EntityBean -- one for each one of the Roller Value Objects. From these classes, EJBDoclet generates a Castor mapping file, the Roller Value Object classes, and a set of corresponding Struts form classes. In Step 2, WebDoclet is used to process a source directory that contains JSP tags, Servlet classes, and Struts classes. The output of the WebDoclet is the complete set of Roller Web Application deployment descriptors.

Figure 4: XDoclet and the Roller Build Process

Below is a simple example bean that shows the EJBDoclet tags necessary to create a Value Object. The @castor tags provide the information needed to generate the Castor mapping entries for the bean. The @ejb tags provide the information needed to generate the Value Object and a complete EJB entity bean (which Roller does not use).

/**
 * Represents a single URL in a user's favorite web-bookmarks collection.
 * @ejb:bean name="Bookmark" type="CMP" jndi-name="roller/Bookmark"
 * @ejb:data-object extends="org.roller.model.ValueObject"
 * @struts:form 
 * @castor:class name="bookmark" table="bookmark" xml="bookmark"
 *               id="id" key-generator="UUID"
 */

public abstract class BookmarkBean implements EntityBean 
{

  /** @ejb:interface-method 
   *  @ejb:transaction type="Required" */
   public abstract void setData(org.roller.model.BookmarkData dataHolder);

  /** @ejb:interface-method */
   public abstract org.roller.model.BookmarkData getData();

  /** @castor:field set-method="setId"
   *  @castor:field-xml node="attribute"
   *  @castor:field-sql name="id" sql-dirty="check" dirty="true" 
   *  @ejb:interface-method 
   *  @ejb:pk-field
   *  @ejb:persistent-field */
    public abstract String getId();

  /** @ejb:pk-field
   *  @ejb:persistent-field */
    public abstract void setId( String value );
    ...
}

Struts

The Roller presentation tier is implemented using Struts and Velocity. Struts is a Servlet application framework that is based on the MVC pattern. In a typical Struts application, the Model is a set of JavaBeans that hold the data to be presented in the View; the View is a set of JSP pages that render HTML; and the Controller is a Servlet and set of action classes that are registered to handle incoming requests.

Roller's Edit-Bookmark form provides a nice, simple example of how Struts works. There are four parts to the Edit-Bookmark form implementation: the edit-bookmark.jsp page, the BookmarkForm JavaBean class, the BookmarkFormAction action handler, and some entries in Roller's struts-config.xml file that tie the first three items together. So, let's introduce the players:

The edit-bookmark.jsp page looks just like an HTML page, except that it uses the Struts HTML form tags instead of standard HTML form tags. The Struts HTML form tags know how to find the BookmarkForm JavaBean and how to use its properties to populate the form with data.
The BookmarkForm class is a dumb JavaBean that just holds data -- it has the exact same properties as the Bookmark Value Object. As you may recall, the BookmarkForm class and all of its sibling form classes are generated by XDoclet. In Struts, form classes must extend org.apache.struts.action.ActionForm.
The BookmarkFormAction is essentially an action handler. It is registered (in the struts-config.xml file) to handle incoming requests that include the pattern /bookmark.do. In Struts, action classes must extend org.apache.struts.action.Action.

Figure 5 shows the sequence of events that occurs when a request for the Edit-Bookmark form comes into the system. Roller needs to respond to this request by creating an HTML form populated with data for the bookmark that is to be edited.

Figure 5: Incoming request for Edit-Bookmark page

Here are the steps in processing an incoming request for the Edit-Bookmark page:

The Struts Controller Servlet receives a request for the Edit-Bookmark action. The Controller uses the URI of the request to look up the FormAction that should handle the request.
The Struts Controller Servlet dispatches the request to the BookmarkFormAction.edit() method. Knowing that the user has requested the Edit-Bookmark page, the BookmarkFormAction looks for a request parameter that specifies the bookmark that is to be edited.
The BookmarkFormAction calls the BookmarkManager to retrieve the bookmark information that is to be edited.
The BookmarkFormAction creates the BookmarkForm bean and adds that bean to the request's attributes so that it can be accessed by the JSP page.
The BookmarkFormAction finally forwards the request to edit-bookmark.jsp so that the page may be rendered.
The Struts form tags on the edit-bookmark.jsp page reads data from the BookmarkForm bean and uses that data to populate the Edit-Bookmark form. After that, the HTML page is returned to the user's browser for display.

Figure 6 shows the sequence of events that occurs when the request that contains posted data from the Edit-Bookmark page comes into the system. Roller needs to take the incoming form data and use it to update the bookmark that is stored in the data store managed by the business tier.

Figure 6: Request with data posted from Edit-Bookmark page

Here are the steps in processing a request with data from a posted Edit-Bookmark page:

The Struts Controller Servlet receives a request for the Update-Bookmark action. The Struts Controller determines which action should handle the request and which form bean should receive the data from the incoming form post.
The Struts Controller Servlet populates the BookmarkForm bean with data from the incoming request.
The Controller calls the BookmarkFormAction and passes in the form bean.
The BookmarkFormAction retrieves the data from the BookmarkForm bean.
The action calls upon the BookmarkManager to store the updated bookmark information.

Velocity

While JSP pages work well for the Roller editor pages, which rarely change, JSP does not work so well for the user pages. Weblog authors are not programmers, and they cannot be required to learn JSP and Java programming just to customize their weblog and associated Web pages. Furthermore, allowing Roller users to add new JSP pages, and thus new Java code, to the Roller application at runtime is a security risk.

Figure 7: Velocity-generated public page

The best solution to the user pages problem is Velocity. Velocity is a general purpose template-based code-generation engine. That may sound complicated, but from the user's point of view, it is simple and easy-to-use. For example, the weblog page shown in Figure 7 is generated by a simple Velocity template. This template is shown below:

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
;<head>
<title>$macros.showWebsiteTitle()</title>     
<style type="text/css">$macros.includePage("_css")</style>
</head>
;<body> 
<table cellpadding="5" cellspacing="15" 
   border="0" align="center" width="95%">   
   <tr>    
   <td width="20%" valign="top" bgcolor="#ffffff">      
      $macros.showNavBar(true)<br>       
      $macros.showEditorNavBar(true)<br>
      $macros.showBookmarks("Blogrolling",true)<br>       
      $macros.showBookmarks("News",true)    
   </td>    
   <td width="60%" valign="top" bgcolor="#ffffff">                
      <h2>$macros.showWebsiteTitle()</h2>                       
      $macros.showWeblogCategoryChooser()<br>       
      $macros.showWeblogEntries()    
   </td>    
   <td valign="top" bgcolor="#ffffff" width="20%">         
      $macros.showWeblogCalendar()<br>       
      $macros.showRSSBadge()    
   </td> 
   </tr>
</table>                  
</body>
</html>

The items that start with $ are Velocity expressions, most of which result in calls to JSP tags that have been specially designed to work with Velocity. For example, the $macros.showWeblogCategoryChooser() expression results in the generation of the navigation bar at the top of the page -- the one that reads "All | Technology | News | Entertainment." The navigation bar is implemented in a custom JSP tag class named org.roller.presentation.tags.NavigationTag, which is also used in the JSP-based Roller editor pages.

Each user can define any number of pages, and since these pages are simply HTML pages, they can be customized using Front Page or any other HTML editor. The user just has to put the Velocity expressions in the right place. Below is a list of some of the Velocity expressions that are available for use in user-defined Roller Web pages.

Macro	Emits HTML for:
$macros.showNavBar()	Navigation bar, with a link to each one of the user's user-defined pages
$macros.showEditorNavBar()	Editor navigation bar, with links to the edit-bookmarks,edit-newsfeeds, edit-weblog, and edit-website pages
$macros.showBookmarks()	Entire bookmark collection in a multi-column table
$macros.showNewsfeeds()	Current headlines and story descriptions for the user's RSS newsfeeds
$macros.showWeblogEntries()	The most recent weblog entries
$macros.showWeblogCalendar()	A weblog calendar, with a link for each day on which there is a weblog entry

Conclusion

In this article, I have described four open source Java development tools and how these tools can be used together to develop a fairly sophisticated Web application. I hope I have given you a good idea of the power and flexibility of these tools.

Although I have not mentioned any problems with the open source tools that I have discussed, I did run into a number of bugs. I was able to find work-arounds and fixes for these bugs, but it was not always easy. I had to spend some time browsing mailing-lists, searching with Google, and, in one case, downloading the latest source for a product and building it myself. Formal technical support is not available for many open source tools, so keep in mind that you may have to solve your own problems.

In closing, I would like to thank the many developers and other contributors that made possible the open source Java development tools that I used in the development of Roller. The tools are great and they just keep getting better.

Resources

Weblogging

Talking Usergrid at ApacheCon 2014

Dave Johnson — Sun, 16 Mar 2014 16:10:16 +0000

I've been working at Apigee since September 2013 and one of the things I love most about my new job is the fact that I'm actively contributing to open source again.

I'm working on Apache Usergrid (incubating), an open source Backend-As-A-Service (BaaS) that's built on the Apache Cassandra database system. Apigee uses Usergrid as part of Apigee Edge (see the Build Apps part of the docs).

Apigee contributed code for Usergrid to the Apache Software Foundation back in October 2013 and Usergrid is now part of the Apache Incubator. The project is working towards graduating from the Incubator. That means learning the Apache way, following the processes to get a release out and most importantly, building a diverse community of contributors to build and maintain Usergrid.

One on the most important parts of building an open source community is making it easy for people to contribute and and that's why I submitted a talk to the ApacheCon US 2014 conference (April 7-9 in Denver, CO) titled How to Contribute to Usergrid.

The talk is intended to be a briefing for contributors, one that will lead you through building and running Usergrid locally, understanding the code-base and test infrastructure and how to get your code accepted into the Usergrid project.

Here's the outline I have so far:

How to Contribute to Apache Usergrid

Motivation
- Why would anybody want to contribute to Usergrid?
First steps
- The basics
- Getting signed up
Contributing to the Stack
- Understanding the architecture & code base
- Building the code. Making and testing changes
- Running Usergrid locally via launcher & via Tomcat
Contributing to the Portal
- Understanding the architecture & code base
- Building the code. Making and testing changes
- Running the portal locally via node.js
Contributing to the SDKs
- Understanding the architecture & code base
- Building the code. Making and testing changes
Contributor workflow: how to get your code into Usergrid
- For quickie drive-by code contributions
- For more substantial code contributions
- For documentation & website changes
Contributing Docs and Website changes
- Website, wiki and GitHub pages
- How to build the website and docs
Roadmap
- First release
- New Core Persistence system
- The two-dot-o branch
- Other ideas

I'm in the process of writing this talk now so suggestions and other feedback are most welcome.

10 years ago today

Dave Johnson — Tue, 17 Apr 2012 07:41:07 +0000

Ten years ago on this day, O'Reilly published an article that I wrote called Building an Open Source J2EE Weblogger, the article that introduced the Roller weblogger (now known as Apache Roller) to the world. It changed my career and my life in a bunch of nice ways and 10 years later I'm still benefiting from my choice to create Roller and write that article. So you can get a taste of the times, here's the intro:

Building an Open Source J2EE Weblogger: As a Java developer, you should be aware of the tremendous wealth of open source development software that is available for your use -- even if you have no desire to release any of your own software as open source. In this article, I will introduce you to some of the most useful open source Java development tools by showing you how I used these tools to develop a complete database-driven Web application called Roller.

Roller fits into the relatively new category of software called webloggers: applications that make it easy for you to maintain a weblog, also known as a blog -- a public diary where you link to recent reading on the Web and comment on items of interest to you.

The Roller Web application allows you to maintain a Web site that consists of a weblog, an organized collection of favorite Web bookmarks, and a collection of favorite news feeds. You can define Web pages to display your weblog, bookmarks, and news feeds. By editing the HTML templates that define these pages, you have almost total control over the layout and appearance of these pages. Most importantly, you can do all of this without leaving the Roller Web application -- no programming is required.

I've written and talked about Roller and the history of Roller numerous times. If you're interested in learning more about it here's my most recent Roller presentation, which covers Roller history in some detail:

Whats New In Roller5

View more presentations from snoopdave

These days, Roller isn't really thriving as an open source project. Wordpress became the de facto standard blogging package and then micro-blogging took over the world. There are only a couple of active committers and most recent contributions have come via student contributions. Though IBM, Oracle and other companies still use it heavily, they do not contribute back to the project. If you're interested in contributing to Roller or becoming part of the Apache Software Foundation, then Roller needs YOU!.

Open-source vs Weblogic and WebSphere

Dave Johnson — Tue, 10 Jan 2012 10:33:53 +0000

Survey says 80% of New Relic's Java customers choose open source app servers over expensive bloat-ware.

Server wars: Open-source Java vs Weblogic and WebSphere | Software, Interrupted - CNET News: Overall, it's not surprising that users who are deploying their applications to the cloud are more likely to use open source, if for no other reason than that licensing is far simpler. Additionally, there are Amazon Machine Images (AMIs) available for most open source stacks, making it very easy to choose open source over a traditionally licensed application server.

Latest Links - July 30, 2011

Dave Johnson — Wed, 20 Jul 2011 15:00:01 +0000

Latest links, favorites and photos shared elsewhere:

snoopdave Shared: Flederhaus - An entire building of hammocks! http://bit.ly/oeEkp9 #fb 03:31:03 PM 29 Jul 2011

jukkaz So much for Java 7 then: http://t.co/7dMuDyV 05:06:33 AM 29 Jul 2011

ryanirelan New Ways of Designing the Modern Workspace http://j.mp/ob3Btu The comments are the best part. Read all of them. 11:37:39 PM 28 Jul 2011

Chris Hostetter: Don’t Use Java 7, For Anything shared 06:21:12 PM 28 Jul 2011

Roller 5 and WebSphere 8 (beta)

Dave Johnson — Wed, 9 Feb 2011 22:18:55 +0000

In my quest to get Roller running on the latest in Java EE servers, the last server I tacked was the WebSphere Application Server. Unlike Glassfish and JBoss, WebSphere's Java EE 6 offering is not available in final form yet. Java EE 6 support is coming in WebSphere 8. So, for this exercise I used the WebSphere 8 beta, which was made available in July 2010. In this blog I'll describe how I approached the problem what I learned along the way.

Deployed the Java EE version of the Roller WAR

If you remember my back to my post on Glassfish, I ended up with two WARs, one for Tomcat and one for Java EE. Then in my post on JBoss, I had to add a special WAR just for JBoss. Fortunately for WebSphere, I was able to use same "Java EE" WAR that I used on Glassfish. It didn't work the first time I tried, but with some code changes and installation guide adjustments, I was able to make it work. Here's a quick summary of the problems I hit:

Problem 1: Commons Logging

I was able to deploy Roller successfully via the WebSphere console, but when I tried to load the Roller setup page I got a 404 error. I looked for the Roller log and found nothing. Something was preventing Commons Logging or Log4J from working properly. After some googling, I learned that this has been a problem on WebSphere for some time and there's an easy (but annoying) fix. I had to add a property file to Roller and ask those installing Roller to add a property file to their WebSphere installation, details are here (ROL-1895).

Problem 2: Filter compatibility

I had logging working but that didn't really help me figure out what was going wrong. Eventually, I remembered the WebSphere Filter Compatibility issue. Servlet Filters are a standard feature of the Servlet API for years, but for some reason they are turned off by default in WebSphere. The solution is to set the com.ibm.ws.webcontainer.invokeFiltersCompatibility flag to true via the WebSphere console and so that's what I did. It worked.

Problem 3: Struts mapping

Once I got beyond the setup page, the Roller bootstrapping page would not load. After some investigation I found that the Struts filter was not being executed. Roller was using the mapping /* meaning that all requests go through Struts. When I changed that to *.rol, which is the extension we use for all Struts actions, things started working. That's what we should have been doing anyway, so I made the change and moved on.

Wrapping up...

In the end, I was able to make Roller's Java EE WAR work on WebSphere and that's a good thing. I really don't want to have a separate WAR for each app server. As I did for the other three servers, I added detailed step-by-step installation instructions for WebSphere to the Roller 5 Install Guide (2MB PDF), with screenshots.

Roller 5 and Glassfish 3

Dave Johnson — Mon, 10 Jan 2011 17:29:36 +0000

In my quest to make Roller work on Java EE 6, the first server that I decided to tackle was Glassfish 3. In this blog I'll describe how I approached the problem and what I learned along the way.

Tested with EclipseLink JPA

Roller uses JPA for persistence and specifically the Apache OpenJPA implementation. I knew that GlassFish uses the EclipseLink JPA implementation and I suspected that there would be JPA portability problems, so I decided to run Roller's JUnit tests against EclipseLink JPA. I wanted to find and fix those problems before even touching GlassFish. The tests ran and there were many JPA related failures and errors, most due to differences in the way that EclipseLink handles bi-directional relationships and the use of unmanaged objects.

Where OpenJPA is lenient about bi-directional relationships, EclipseLink requires you to manage both ends. For example, with OpenJPA you can get away with adding a bookmark to a folder with folder.addBookmark(bookmark), but with EclipseLink you'd also have to add bookmark.setFolder(folder).

Where OpenJPA is lenient about use of unmanaged objects, EclipseLink will complain bitterly whenever it finds one in a persisted collection or relationship. This was more of a problem in the tests than in the actual Roller code, which usually deals only with managed objects (i.e. those persisted to / loaded from the database and managed by the JPA implementation).

I was able to fix those problems easily and move onto the next step.

Created a Roller WAR without OpenJPA

I also knew that Roller included some jars needed for Tomcat but that are not needed, or worse, problematic, on true Java EE servers. For example, we include the Apache OpenJPA implementation because Tomcat doesn't have one of its own. I modified the Roller build process to create two builds. One build is for Tomcat and includes OpenJPA and the other build is for Java EE and does not.

Deployed, tested and updated the docs

Next, I figured out how to deploy Roller to GlassFish 3 via the GlassFish web console, which was pleasant to use and familiar to me. I didn't run into any problems along the way and later I documented the whole process in the Roller 5 Install Guide (2MB PDF), with screenshots.

Next up: Roller 5 on JBoss 6

Built with Maven

Dave Johnson — Sun, 14 Mar 2010 09:47:26 +0000

I was a Maven hater and resisted it for a long time but over the years Maven has gotten much better, it's well supported in IDEs and as far as I can tell, Maven has replaced Ant as the de facto build system for Java projects. If you want new developers be able to easily build, debug and run your code via command or their favorite IDE then Maven is the way to go, and that's especially true for open source projects like Roller.

That's why I spent a couple of weekends learning Maven and converting Roller's build process from Ant to Maven (ROL-1849). The process of conversion wasn't too difficult. Getting dependencies under control was a pain, but it believe it will be a one time pain and a worthwhile one. What took the most time was figuring out how to get Maven to start Derby, create the Roller tables and then run Roller's JUnit tests. Also, getting Maven's Jetty plugin setup to run Roller was a little tricky but hopefully also a one-time pain. The result is that Roller now uses a standard and well known directory structure, dependencies are managed and it's easier for developers to get started with the codebase.

If you have Maven and Subversion installed on your computer then these commands will fetch the Roller source code, compile the code, run all JUnit tests and then build the Roller webapp:


   svn co https://svn.apache.org/repos/asf/roller/trunk roller_trunk
   cd roller_trunk 
   mvn install

And once all that is done, the following commands will start the Jetty app server, start the Derby database and start Roller at http://localhost:8080/roller, ready for testing, experimentation, etc.


   cd weblogger-web
   mvn jetty:run-war

I think that's pretty damn useful.

Here are some articles/links that influenced my thinking on Maven recently:

Comparing Build Systems - Adrian Sutton concludes that Maven is too much work but "the consistency in how a project is built that the Maven project has brought to the Java would is absolutely revolutionary"
Maven in our development process - Sherali Karimov explains how Atlassian and says the need for Maven training is "the most important and most overlooked issue of all."
Sonatype - The Maven Company. Founded in 2008 by Jason van Zyl, the creator of Maven. Offers training, support and the Nexus Professional repo manager.

Roller Beginner's Guide available

Dave Johnson — Thu, 25 Feb 2010 07:54:11 +0000

I blogged about Alfonso Romero's Apache Roller 4.0 Beginner's Guide book before. It's a great resource for folks who want to get the most out of their Apache Roller-based blogs, and not just beginners. As you can see in the photo on the right, I've got my copy. You can get yours directly from Pakt publishing:

Buy a copy of Beginner's Guide to Apache Roller 4.0

To publicize the book, Pakt publishing has been publishing some useful excerpts and even a complete sample chapter online. Here's summary of the excerpts so far:

If you've been following Roller development you know that Roller 5.0 is on the way. Most of the changes in Roller 5.0 are "under the hood" so 5.0 won't make Alfonso's book obsolete. Except for a couple of pages in Chapter 5 "Spicing Up Your Blog" that need updated screenshots, I believe everything in the book applies to Roller 5.0 as well.

Month of blogging

Dave Johnson — Sun, 2 Aug 2009 16:04:33 +0000

Crammed into one post...

After a month of blog neglect, the automatic Latest Links posts from my Delicious.com account started to pile up in my blog editor. Back in the glory days of this blog, I blogged about things instead just saving links or tweeting about them and would never have let a month go by without blogging. I realized that, by adding some commentary/opinion for each, I could turn a month's worth of links into a month's worth of blog posts and thus gain total absolution for my sin of going a full month without a post. So that's what I did.

ul.linkentry>li {margin-bottom:0.5em;} ul.linkentry>li span {color:gray; font-style: italics}

Category: Blogging

Joe Gregorio: Comment system review
"Comparing Disqus, IntenseDebate and Google Friend Connect." Joe Gregorio looked at commenting systems and ended up chosing Intense Debate.
Integrating Disqus and Roller Weblogger on blogs.sun.com
"I've recently updated my site to use Disqus the blog comment hosting and conversation site." Sun UK CTO Wayne Horkan explains how (and why) to use the Disqus in a Roller, with code and helpful comments from Disqus CEO Daniel Ha.
Official Google Blog: New Blog Search tools
"Feeds, Hot Queries and Latest Posts." Nice to see Google is still working on blog search despite the rumored death of blogging.

Category: Feeds

pubsubhubbub - Google Code
"A simple, open, server-to-server web-hook-based pubsub (publish/subscribe) protocol as an extension to Atom." Collaboration between Google and SixApart folks to allow quick notifiation of new content to feed subscribers and reduce load on feed publishers. Hub implementations are underway for AppEngine/Python, Erlang, Python and Ruby. Hmm... no Java?

Category: General

The Ryding List | Why Not?
"I have found a wealth of great things to do in Raleigh." Great list of things to do around Raleigh by newcomer John Ryding, one of my coworkers at IBM.
The Different CTO Roles - All Things Distributed
"there is no well established definition of what a CTO actually does." Of special interest to me now that I work on a CTO's staff.
Life During Wartime video from Stop Making Sense - Boing Boing
"This is the best concert movie I've ever seen." Me too.

Category: IBM

Integrating and Extending Rational Team Concert 2.0
Great guide and presentation on Team Concert development via the Jazz Server SDK. Referring to this a lot these days.
Eclipse Galileo for Mac: Cocoa or Carbon?
"Carbon is more mature and thoroughly tested, the new Cocoa implementation offers advantages and improvements." And the answer is: 32-bit Cocoa. Yep, I'm paying attention to Eclipse again. It's really the only way to do Jazz development.
Whitepaper: e4 Technical Overview
Lots of detail on the apparently massive changes coming in Eclipse e4 including the ability write Eclipse components in JavaScript and to run "existing SWT applications to be executed on web platforms such as ActionScript/Flash."

Category: Java

James Strachan: Scala as the long term replacement for Java
"if someone had shown me the Programming Scala book back in 2003 I'd probably have never created Groovy." I'm sure that sent a lot of folks to Amazon, including me.
Google App Engine plugin in NetBeans
"With a video showing how easy it is to develop Google App Engine application in NetBeans. You can see that Hello World takes just 1 minute. :-)" Looks good and apparently it's an open source side-project. Hosted at Kenai.
Trails of EasyExtend: Java Spring - or the Biggus Dickus effect
"Looking at the API alone Spring feels like reading a parody on Java enterprise software." Schadenfreude for me; never been a fan and always thought of it as a big grab bag of insidious crap I don't need.

Category: Open Source

NYTimes.com: For Mozilla and Google, Group Hugs Are Getting Tricky
"Google pays Mozilla hefty fees in return. The deal accounted for 88 percent of Mozilla's $75 million in revenue in 2007." Makes you wonder about the future of Firefox, Thunderbird, etc.
Official Google Blog: Introducing the Google Chrome OS
"The software architecture is simple: Google Chrome running within a new windowing system on top of a Linux kernel." Yet another Linux distro. That's cool with me; I like Linux distros.
The Java Wars, continued (Scripting News)
"most people want XP on their netbook, not Linux. That was true yesterday and it's still true today." Dave Winer's take on Google's Chrome OS. I think he's probably right at the moment but things are changing rapidly.

Category: Social Software

Creating a Google Data Gadget - Google Data APIs - Google Code
"This article will walk you through creating a Blogger gadget." Google and OpenSocial Gadget support for OAuth makes things easier, but it's still a PITA.
Writing OAuth Gadgets - Gadgets API - Google Code
"send mail to oauthproxyreg@google.com with the following information to register your OAuth Consumer Secret." If you want to write a Gadget that uses OAuth to access Twitter there's an icky manual registration step involved. Apparently the solution to this problem is for Twitter.com to enhance their "OAuth configuration to accept digital signatures directly from iGoogle."

Category: Sun

The end of Sun
"And that is why Schwartz isn't here, I believe. Because he genuinely loved Sun and its employees." A depressing article for former Sun employee to read, or anybody I guess. I do think there is something to this quote about Scwhartz.
Oracle-Sun Creating Churn - Forbes.com
"Suns loyal customers are defecting in droves." Not really very surprising considering the conventional wisdom, which seems to be that Oracle will gut Sun's software efforts and ditch the hardware entirely.
Computerworld Blogs: Is Oracle getting ready to kill OpenSolaris? -
"Sun, Oracle and third-party sources are telling me that OpenSolaris developers are afraid." This article is typical of what I've seen from the author: dumb speculation of the mean-spirited variety.
Justice department extends Oracle-Sun probe
"All that's left is one narrow issue about the way rights to Java are licensed." I don't there's a chance in hell that it is, but wouldn't it be fun if this was all about the Sun-Apache Terms of Use controversy?

Web development

InfoQ: Twitter, an Evolving Architecture
Brief overview of Twitter architecture, use of caching and message queue technologies.
Evaluation of Javascript Libraries
"jQuery and YUI come out on top, Prototype at the bottom." Helped convince me that, now that we have YUI, we don't really need Prototype and Scriptaculous in Roller.
"MooTools vs JQuery vs Prototype vs YUI vs Dojo revised
"Prototype is among the slowest." More justification for ripping out Prototype and Scriptaculous.

And now, back to your regular schedule of blogging, or not.

RSC 2009: connecting developers and community

Dave Johnson — Tue, 26 May 2009 22:22:00 +0000

I've attended every JavaOne since 2004, but this year I've got new job and a new conference to attend. This year I'll be traveling to Orlando, FL and attending the Rational Software Conference also known as #rsc2000 in the twit'o'sphere.

I'm not going to be giving a talk, but I will be manning a demo pedestal and showing some of what I've been working on in my first couple of months at IBM: working on getting Rational Team Concert and other Jazz-based products to work well with Lotus Connections, IBM's social software suite which includes communities, forums, blogs, bookmarking, social networking and wikis (coming soon in Connections 2.5).

Why would you want to use Team Concert with Connections? It's all about connecting developers to community, helping developers use social software tools to inform, share and collaborate with the wider community of people that support, manage, sell and use the software.

The tentative plan that we've outlined for all (registered users) to see on the Jazz.net is all about making it easy to setup and integrate community infrastructure for a new software project.

For example, wouldn't it be nice if, when you setup a new project in Team Concert you'd have the option of setting up an integrated Lotus Connections community complete with a project blog, discussion forum, wiki space and shared bookmarks? Shouldn't those blogs, forums and wikis be searched when you do a project search and shouldn't it be dead-simple to fire-off a blog entry or forum post to start a community conversation about a work-item or any other Team Concert artifact? We think so and we think that's just a start; there's lots more we can do.

If you're going to be at RSC 2009, please stop by and say hi. I'll be on duty from 5-8PM on Monday and most of the day Tuesday. Whether you're there or not, if you've got ideas about developer tool and social software integration, I'd love to hear from you.

Media Blogging for Roller

Dave Johnson — Thu, 19 Feb 2009 12:57:37 +0000

For the past five months I've had the pleasure of mentoring two San Jose State Univ. graduate students, Ganesh Mathrubootham and Tanuja Varkanthe, who are working on a project for classes CMP 295A and B. They picked one of the projects that I first proposed for Google Summer of Code and then for Glassfish's student outreach program, Media Blogging for Apache Roller. It's turned out to be a major project and the central new feature in the upcoming Roller 5.0 release.

The plan

The basic idea is to make it really easy to upload images, audio and video files to Roller, and really easy to include them in Roller blog posts and RSS/Atom feeds. Of course, the devil is in the details and Ganesh and Tanuja really have those covered. They have put together the most detailed and well thought-out plan and design ever for a new Roller feature. You can find the proposal page and the full Media Blogging for Roller Project Plan (PDF, 2mb) on the Roller wiki. Here's a key excerpt from the project summary:

Roller currently lacks support for the latest blogging features. Roller does allow users to upload any type of content to their blogs and include that content on blog entries as images or podcasts, but lacks tools to make media blogging a seamless experience for bloggers. Interface to manage uploaded files is not sortable and not page-able. Once the user has uploaded a file, which could be an image or a podcast, he needs to explicitly cut and paste the URL into his blog post.

Overall, Rollerâ€™s support for media blogs is currently limited to basic file upload functionality, which is cumbersome to use for creating media blogs. This project will revamp the existing file upload interface to incorporate powerful media blogging features into Roller. Also, successful media management websites such as Flickr and YouTube are driven by a public media library, offering different ways for users to search and locate the content of their like. This feature incorporated into a blog server can make it very powerful and we intend to do that as part of this project.

To get an idea of what this is all about, let's take a look at some screenshots/wireframes taken directly from the project plan.

New media file upload dialog

First up is the new media file upload dialog. There are a couple of interesting things here. We'll have metadata for each upload, including description, tags and copyright message. We'll also have the option of including the file in the gallery. We'll support a media gallery for each blog, and new files added to the gallery are included in a special media feed for the blog.

File Uploads browser

To make it easy to manage your media files, the proposal includes a new upload browser interface, with a tabular and a hierarchical view. Thumbnails will be automatically generated on upload. Search and filtering controls will make it easy to find and operate on the files you are looking for, based on file metadata.

Select media dialog

When you are writing a blog post, you'll be able to browse for and include media files without leaving the blog editor interface. You'll be able to choose the size and orientation of the image or video in the blog post, as you can see below.

Needless to say, I'm pretty excited about these new features, and to looking forward to a major new Roller release, and one where I don't have to do much of the work. If you want more information on 5.0 then check the Apache Roller 5.0 proposal page. And if you want to help out then join the Roller development mailing list and introduce yourself.

ROME 1.0 RC2 on the way

Dave Johnson — Wed, 7 Jan 2009 08:48:11 +0000

Good news for ROME fans. Nick Lothian picked up the puck and is galloping towards the finish line (sorry, I'm terrible at sports analogies).

Nick Lothian on ROME dev:

I've gone and built some preview jars for the upcoming ROME 1.0RC2, ROME Fetcher 1.0RC2 and Modules 0.3 release.

Those jars can be found here: https://rome.dev.java.net/servlets/ProjectDoc...

I've created source and javadoc jars as well as the normal jars - the idea being that I'll get them uploaded to some maven repository.

If you have some spare time, please take a look at these and test them and let me know of any problems. Assuming there are no big issues found I'd like to do a proper release in a couple of days.

Guess that means I should test Propono with RC2.

Sun should give up on the desktop?

Dave Johnson — Tue, 25 Nov 2008 17:27:19 +0000

Tim Bray: What Sun should do: Sun is going through a lousy spell right now. Well, so is the worldâ€™s economy in general and the IT business in particular, but this is about Sun. This is my opinion about what my employer should do about it.

It takes a lot of guts to write a piece like that and I'm really glad Tim did it. I'm going to walk out on the same limb and agree with pretty much everything Tim wrote. Tim wants Sun to focus like a laser on providing the best web platform around with Solaris, storage offerings, Java/Hotspot, Glassfish, MySQL and Netbeans for Java, Ruby, PHP, Groovy, etc. tooling. He writes:

Itâ€™s easy to understand how our servers, CMT and x86, and the Solaris OS, fit into the Web Suite. All the software, including the HotSpot, GlassFish, and MySQL runtimes, needs to be obsessively tuned and optimized to run best in the context of the Suite. Obviously, the Suite will also include Ruby and Python and PHP runtimes, similarly tuned.

All of Sunâ€™s software tooling should have a laser focus on usability, performance, and ease of adoption for the Web Suite.

I agree, but as a web geek I guess I'm pretty biased.

Tim doesn't shy away from the critical question of what Sun should stop doing. Tim says Sun should give up on the client-side, dropping JavaFX and JavaME (and OpenOffice too, I presume). Here's Tim on JavaFX:

For actual business apps, the kind that our servers spend most of their time running, the war for the desktop is over and the Web Browser won. I just totally donâ€™t believe that any combination of Flash and Silverlight and JavaFX is going to win it back.

I can't say I disagree with that either. Cutting JavaFX and JavaME would be extremely tough and painful decisions, but somebody's going to make to make some of those. Looking at things from Tim's web-platform-only point of view, they make sense. Sun needs only enough client-side software to keep Solaris attractive to developers and to support great development tools on all the platforms that web developers love.

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.

SocialSite's Flexible Relationship model

Dave Johnson — Wed, 19 Nov 2008 10:47:21 +0000

Image by flawedartist

We're designing Project SocialSite to support the needs of any site that wishes to add Social Networking features and support OpenSocial. That means we have to be flexible.

We can't hard-code the names of different types of relationships because some sites might want to call friends "buddies" and some might call them "connections." Some sites might want multiple levels of relationships, with some relationships being considered stronger than others, like on Flickr where you have contacts, friends and family. Some sites might want to allow one-way relationships, as Twitter does with "followers," but some sites might want to require that relationships be two-way, as Facebook does.

We want SocialSite to have a Flexible Relationship model that a site operator can tweak to suit the unique requirements of her site's community. We've settled on a model based on relationship types and named levels. In this post, I'll review this new model that we have designed in hopes of getting some feedback, push-back and other good things that might help us refine our model.

I) Relationship Types

SocialSite is designed to support the types of personal relationship shown below. This doesn't include group relationships, which are handled separately.

One-way relationship: A relationship from one person to another person that is not reciprocated. For example, Fred has a relationship with Bob, but Bob has no relationship with Fred. Another example: a follower relationship as you see in Twitter.
Two-way relationship: A relationship from one person to another that is reciprocated. For example, Fred has a relationship with Bob and Bob also has one with Fred. Another example is Facebook, which requires friendship relationships to be two-way.
Mutual relationship: Fred and Bob have a two-way relationship and have agreed on a "how we know each other" message. This is more meaningful than a two-way relationship, because the two parties have agreed on some shared item of information about the relationship like "we met at band camp."

II) Relationship Levels

SocialSite can be configured to support multiple relationship levels like Flickr's contacts, friends and family levels. Users can use these levels when sharing information, e.g. share a photo only with relationships of family-level or higher. I'll explain how the configuration works, but first let's define what we mean by relationship level.

Relationship Level

A Relationship Level is a named integer index that is assigned by one person to indicates the strength of a relationship with another person. People only know the levels that that they have assigned to relationships, so one person in a relationship won't feel slighted if the other party thinks less of the relationship than they do. For example, Fred might consider Bob to be a level 2 "Close Friend" but Bob considers Fred only a level 1 "Acquaintance" relationship. Fred won't learn about this (unless Bob tells him).

You can configure the relationships levels and names supported by SocialSite via the property 'socialsite.relationship.levels'. You simply provide a comma separatied list of the I18N keys of the relationship level names, in order from no-relationship to the strongest level. Here is the default setting, which establishes three relationship levels 0=none, 1=contact and 2=friend:

  socialsite.relationship.levels=\
  relationshipLevel.none,\
  relationshipLevel.contact,\
  relationshipLevel.friend

OpenSocial doesn't define differently named relationship levels like we do, so we need to do some mapping. OpenSocial has one type and one level of relationship called "friend." So, to map SocialSite relationships to OpenSocial, we have introduced the notion of a friendship level.

Friendship level

Friendship level is an integer configuration property which indicates the relationship level that is considered to be the friendship relationship across a SocialSite system. Relationships at or above this level are considered to be friends when returning data via OpenSocial APIs. Also, when you add a relationship at friendship-level or above, the other party will be notified and given the opportunity to add you as a friend too. You can configure the friendship level via the property below:

  socialsite.relationship.friendshiplevel=2

It's good to have the flexibility to support both one and two-way relationships, but we can't assume that all sites will want both. Some social network services, like Facebook, require that friendship-level relationships be two-way, i.e. both parties must agree that they are friends. To make such a setup possible with SocialSite, we've introduced the configuration property below:

  socialsite.relationship.twoway.requiredForFriendship=true

If that property is true, then any relationship that is considered a friendship (relationship level >= friendship level) must be a two-way relationship. So, when you add a relationship at friend-level or above, the other party must reciprocate or the relationship will not be created.

III) Example SocialSite configurations

To better explain how SocialSite Flexible Relationships work, here are some example configurations that configure SocialSite to behave like well-known social network services.

-like configuration. Flickr supports relationship levels of Contact, Friend and Family. It's possible for you to consider somebody to be Family, while they only consider you only to be a Contact. Any level relationship is considered to be a friendship relationship, for the purposes of OpenSocial.

  socialsite.relationship.levels=\
     relationshipLevel.none,\
     relationshipLevel.contact,\
     relationshipLevel.friend,\
     relationshipLevel.family
  socialsite.relationship.friendshiplevel=1
  socialsite.relationship.twowayRequiredForFriendship=false

-like configuration. Twitter supports one relationship level and that is follower. Its possible for you to follow somebody that does not follow you.

  socialsite.relationship.levels=\
     relationshipLevel.none,\
     relationshipLevel.follower
  socialsite.relationship.friendshiplevel=1
  socialsite.relationship.twowayRequiredForFriendship=false

-like configuration: Facebook supports one relationship level and that is friend. Friendships are required to be two-way, so we have this:

  socialsite.relationship.levels=\
     relationshipLevel.none,\
     relationshipLevel.friend
  socialsite.relationship.friendshiplevel=1
  socialsite.relationship.twowayRequiredForFriendship=true

The default SocialSite configuration. We're considering the below settings for our default configuration. This would allow you to have contacts, with which you can share information but who are not considered friends and would not show up in your friends list or be returned as friends via the OpenSocial APIs.

  socialsite.relationship.levels=\
     relationshipLevel.none,\
     relationshipLevel.contact,\
     relationshipLevel.friend
  socialsite.relationship.friendshiplevel=2
  socialsite.relationship.twowayRequiredForFriendship=true

IV) Wrapping up...

That just about covers it, so I'm going to wrap up now. Most of the above is now implemented in SocialSite, but none of this stuff is carved in stone. So your feedback is more than welcome, either here or on the SocialSite development or user mailing lists.

CommunityOne call for papers is open X 2

Dave Johnson — Wed, 19 Nov 2008 08:12:27 +0000

Next year there will be two CommunityOne events in the US of A; one in New York City on March 18 and the other, coinciding with JavaOne week in June 1 in San Francisco. Here's the call for papers link. The call closes on December 11.

Details of Roller setup at blogs.sun.com

Dave Johnson — Tue, 18 Nov 2008 15:33:52 +0000

Meena Vyas, Murthy Chintalapati and Allen Gilliland just published an article on BigAdmin that describes the architecture of blogs.sun.com, a Roller, Sun Web Server, Memcached and MySQL based site that averages 4 million hits a day with its two SunFire T2000 servers at 97% idle. You can get the article for free (registration required) here: Sun Blogs: A Sun Java System Web Server 7.0 Reference Deployment

Another vote for RESTful JSF

Dave Johnson — Tue, 26 Aug 2008 08:27:33 +0000

From the Seam Framework team's wiki page on JSF2 major issues:

The JSF2 expert group should work closely with the JSR 311 expert group to define overlapping integration points (unified configuration) and programming models, so that a JSF implementation can work seamlessly with a JAX-RS implementation. For example, a @Path annotated POJO should work as a JSF backing bean without any additional configuration. A JSF application programmer should be able to expose RESTful remote APIs easily.

Right on.

Via Matt Raible

Social Roller

Dave Johnson — Mon, 25 Aug 2008 19:51:31 +0000

We demonstrated the Project SocialSite widgets in Roller at JavaOne, but we didn't show much other than just the basic widgets. We modified a Roller front-page theme to include a people directory, added a profile page for each user and slapped the widgets on the page. It was pretty rough, as you can see on the right, like our other SocialSite demo vehicles.

This week, I'm working to put together a much better demonstration, something useful enough to deploy to our internal blog site at Sun. Since I have limited time and I really need to get back to working on the SocialSite widgets and web services, I've been thinking about minimum set of features needed to add some value. Here's what I think we need:

Landing page: shows activities of your friends and groups, your inbox of social requests and place for you to update your status. This could be added to Roller's Main Menu page or to pages of the Front Page blog, which is my preferred option.
Personal profile page: shows your mugshot and the subset of your profile information that the viewer is allowed to see. Shows your activities and the OpenSocial gadgets you have installed. This could be done in the pages of each user's blog, which would give folks complete control of profile layout via page templates. Or I could be done in the pages of the Front Page blog.
Activity per entry or comment: whenever you publish a weblog post, or comment on one, an entry will be added to your activity feed so that your friends can see what you're doing. This will be implemented as a feature of a Roller-specific OpenSocial Gadget.
Protected entries: ability to publish blog entries that are visible only to your friends via the Roller Gadget.

Most of the above items should be pretty easy with the SocialSite widgets, but I'm sure I'll run into a snag or two at least. I always do. I'll post again next week and let you know how far I got.

RESTful JSF in the works?

Dave Johnson — Fri, 8 Aug 2008 15:52:58 +0000

JSF spec lead Ed Burns just pointed out that some of my Sun-internal comments about JSF have made it outside the firewall and into an issue on the JSF specification project:

On Wed, 19 Mar 2008, David M Johnson said:

I think the goal should be to make JSF applications RESTful by default, with proper use of GET and POST, i.e. only use POST when application data is changing, not for component state. Another goal should be clean, book-markable URLs that only carry path-info and parameters needed by the application logic.

That's easy and the default situation with Rails, Grails, Struts, etc. How hard would it be to redesign JSF along those lines? Would it require EJB2 -> EJB3 level changes to JSF?

I suspect work on JSF 2.0 is too far along for this kind of change now, but it's nice to hear that the idea of a truly RESTful JSF is at least under consideration.

Latest Links

Dave Johnson — Tue, 8 Jul 2008 14:00:05 +0000

InfoWorld 2008-07-07 Lab test: Climb aboard Ruby on Rails
Interesting that the best rated Ruby-on-Rails IDE is the one that is free & opensource. Go Netbeans!
ongoin Â· Atomic Monday
"Herewith some evidence, for the general tech public, that Atompub is a big deal"
InfoQ: AtomServer â€“ The Power of Publishing for Data Distribution
"a distributed, publish-subscribe service is a great way to address resiliency and loose coupling of subsystems"
blog.reddit -- what's new on reddit: reddit goes open source
"Until now, the only portion of reddit that wasn't freely available is reddit itself"
OAuth for Google Data APIs
"we're proud to announce that all of the Google Data APIs support OAuth"
Google Code Blog: Protocol Buffers released as Open Source
"think XML, but smaller, faster, and simpler"

Daily Kos: Cars After The Age of Oil
"We can switch to a new tech that is older and simpler than the Internal Combustion Engine - the electric horseless carriage was first created in 1830"
Wired.com: Laugh at High Gas Prices With a 282-MPG VW
"VW has approved a plan to build a limited number of One-Liters in 2010"
SAS Solar Farm | New Raleigh, NC
"Our local 500 pound software gorilla is building a five acre, one megawatt photovoltaic solar farm"

LinkedIn: 99% Pure Java

Dave Johnson — Thu, 5 Jun 2008 09:07:23 +0000

Nick Lothian tweeted about this JavaOne presentation on LinkedIn because it mentions the ROME RSS/Atom feed parser. I'm really sorry I missed it at JavaOne. What's particularly interesting to me are the diagrams that explain how the LinkedIn architecture has evolved to scale up to 22 million users. Here's an example:

Struts 2 in Action

Dave Johnson — Wed, 7 May 2008 12:19:49 +0000

Struts 2 is my favorite Java web framework these days; it's REST-friendly, simple, easy to use, very flexible and the only thing it has with its creaky old Struts 1.x parent is the fact that it's an action framework rather than a component framework like JSF. As most of my readers probably already know, Struts 2 is based on WebWork/XWork the framework that powers JIRA and Confluence, two of the coolest Java webapps around.

Apparently, I'm not alone in this thinking -- I keep on running into folks at JavaOne who feel the same way. But unfortunately, Struts 2 docs are lacking, so I was very happy to see two new books on Struts 2 at the JavaOne bookstore. There's Struts 2 in Action, a rewrite of the classic Manning book, and <a href= "http://www.apress.com/book/view/1590599039">Practical Apache Struts 2 Web 2.0 Projects from Apress.

I picked up a copy of Struts 2 in Action on Monday and it looks great so far, but I've only skimmed it. I'll let you know what I think once I dig-in on the flight home.

If you're at JavaOne, check out TS-5739 - Hands-on Struts2 by Ian Roughley (author of the Apress book) today at 10:50 AM in Esplanade 307/310.

Social Software at JavaOne 2008

Dave Johnson — Tue, 29 Apr 2008 15:00:08 +0000

There are quite a number of Social Software related talks coming up at JavaOne and CommunityOne this year. You can learn about everything from building Social Networks with the Liferay portal and federated relationships with OpenSSO to creating 3D virtual works and implementing OpenSocial with Java. And, I'll finally be able to talk about what I've been working on for the past couple of months -- more about that later.

Here are the 11 Social Software related talks that I've found so far at both JavaOne and CommunityOne. Did I leave any out?

CommunityOne - Monday

<a href= "http://www28.cplan.com/cc197/session_details.jsp?isid=297141&ilocation_id=197-1&ilanguage=english"> S297141 - Building a Social Network with Liferay Portal
Brian Chan, Liferay, Inc.
Monday May 05 12:25 - 13:20 / Moscone North - Hall E 135
<a href= "http://www28.cplan.com/cc197/session_details.jsp?isid=297226&ilocation_id=197-1&ilanguage=english"> S295742 - Turn Your Web Site into an OpenSocial Container
Dave Johnson and Vijay Ramachandran, Sun Microsystems, Inc.
Monday May 05 14:35 - 15:30 / Moscone North - Hall E 135
<a href= "http://www28.cplan.com/cc197/session_details.jsp?isid=297300&ilocation_id=197-1&ilanguage=english"> S297300 - OpenSSO: Federated Relationships with Social Networking and Web 2.0
Pat Patterson, Daniel Raskin and Nick Wooler, Sun Microsystems, Inc.
Monday May 05 16:00 - 16:55 - Moscone North - Hall E 135

JavaOne - Tuesday

<a href= "http://www28.cplan.com/sb191/session_details.jsp?isid=296125&ilocation_id=191-1&ilanguage=english"> TS-6125 - Project Wonderland: A Toolkit for Building 3-D Virtual Worlds
Paul Byrne and Jonathan Kaplan, Sun Microsystems, Inc.
Tuesday 05/06/2008 3:20 PM -4:20 PM / North Mtg-121/122/124/125

JavaOne - Wednesday

<a href= "http://www28.cplan.com/sb191/session_details.jsp?isid=296574&ilocation_id=191-1&ilanguage=english"> TS-6574 - How to Implement Your Own OpenSocial Container with Java
Chris Schalk, Google
Wednesday 05/07/2008 1:30 PM -2:30 PM

JavaOne - Thursday

<a href= "http://www28.cplan.com/sb191/session_details.jsp?isid=296362&ilocation_id=191-1&ilanguage=english"> BOF-6362 - LinkedIn: Prof. Social Network Built with Java and Agile Practices
Nick Dellamaggiore and Eishay Smith, LinkedIn
Thursday 05/08/2008 6:30 PM -7:20 PM / Esplanade 301
<a href= "http://www28.cplan.com/sb191/session_details.jsp?isid=295857&ilocation_id=191-1&ilanguage=english"> BOF-5857 - Turn Your Web Site into an OpenSocial Container
Dave Johnson and Jamey Wood, Sun Microsystems, Inc.
Thursday 05/08/2008 6:30 PM
<a href= "http://www28.cplan.com/sb191/session_details.jsp?isid=296575&ilocation_id=191-1&ilanguage=english"> BOF-6575 - Building OpenSocial JavaServer Faces Components
Ed Burns, Sun Microsystems, Inc.; Chris Schalk, Google
Thursday 05/08/2008 7:30 PM -8:20 PM
<a href= "http://www28.cplan.com/sb191/session_details.jsp?isid=295911&ilocation_id=191-1&ilanguage=english"> BOF-5911 - Beatnik: Building an Open Social Network Browser
Tim Boudreau and Henry Story, Sun Microsystems, Inc.
Thursday 05/08/2008 7:30 PM -8:20 PM
<a href= "http://www28.cplan.com/sb191/session_details.jsp?isid=296435&ilocation_id=191-1&ilanguage=english"> BOF-6435 - Creating Facebook and OpenSocial Widgets with Java
Florent Gerbod and Kevin Leong, Mo'Blast Inc.
Thursday 05/08/2008 8:30 PM -9:20 PM

JavaOne - Friday

<a href= "http://www28.cplan.com/sb191/session_details.jsp?isid=296537&ilocation_id=191-1&ilanguage=english"> TS-6537 - Applications for the Masses by the Masses
Girish Balachandran and Todd Fast, Sun Microsystems, Inc.
Friday 05/09/2008 10:50 AM -11:50 AM

Latest Links: open source, social networking and etc.

Dave Johnson — Sun, 23 Mar 2008 14:00:05 +0000

cgwalters - A software tsunami
"OpenJDK is finally changing that. Now, you can write a library using Java, it can be sensibly integrated with Free operating systems"
Countdown for IBM Project Zero | Reg Developer
"bringing the feedback typical of an open source project without any of the obligations to give the resulting technology back to the community."
Soviet-era JCP needs change, concedes top commissar | Reg Developer
Patrick Curran has reached a firm conclusion on his organization: "We have to change," he said. "No more smoke-filled rooms."
Glynn Foster: Why Our Governance Doesnâ€™t Work
"Thereâ€™s no substitute to JFDI - or improving our governance model so that it doesnâ€™t get in the way of suitably motivated people who want to contribute."

Skype Journal: Skype and the Social Network Stack
"We need a new stack to sort out social media's plumbing"
An Open Letter to American Express ~ Chris Pirillo
"You know, for all the buzz that FaceBook getsâ€¦ I get far more value out of Twitter."
buddypress - Google Code
"suite of plugins that will completely transform a vanilla installation of Wordpress MU into a fully functional social network platform"

App Platform Strategies Blog: Looking for SOA success stories
"SOA is not working in most organizations"
OLPC News: Negroponte Says XP on XO in 60 Days
"the end of a dream".
Atlassian Dev Blog - Maven in our development process. Part 4.
"Maven users need training."

HOWTO: Configure caching in Apache Roller

Dave Johnson — Mon, 3 Mar 2008 12:15:00 +0000

Since the early days, Roller has included a pluggable caching system for blog pages and feeds. In Roller 2.1 (early 2006), Sun's Allen Gilliland rewrote the whole cache system and made it much more flexible and much easier to configure. But, apart from comments in the configuration file, we never provided any documentation for the cache system. In this post, I'll start to correct that. I'll explain the basics of how the cache works and how to configure it.

Overview

Displaying a blog page can take dozens of database queries and database queries can be expensive. They take time, consume CPU cycles and typically use network bandwidth. Roller's built-in caching system addresses this problem by caching generated pages and feeds. By default, Roller caches pages and feeds in memory using a Least Recently Used (LRU) algorithm and by default caches are configured appropriately for a 100 blog system. If you are running a site with more blogs or a very high-traffic site, you should consider changing the caching configuration. First, let's discuss how the caches work.

Cache invalidation and expiration

When Roller generates a page, it puts a copy of that page in a cache. The next time that a request comes in for that page, Roller returns the page from the cache. When a blog changes, Roller invalidates the blog's cache enties, i.e. it throws that blog's pages out of the cache. And by default, when the cache is full and we need to add a new entry to the cache, we push out the least recently used entry in the cache to make room; that's the LRU algorithm I mentioned before.

Sometimes, a blog page includes things that change frequently like a list of referrers or a server-side hit counter or data from some other source. We don't want to invalidate a blog's cache entries every time a hit is counted. That would defeat the purpose of the cache. So, by default Roller uses an expiring cache that automatically invalidates cache entries after timeout period.

Cache configuration

To configure the Roller caches, you add properties to your roller-custom.properties properties override file. You can learn more about this override in Section 6 of the Roller 4.0 Installation Guide and you can find a complete list of the properties you can override in Section 11.

First, let's cover the default caching mechanism. If you're running a large and high-traffic site, you might want to consider using the non-expiring cache or setting the cache timeout very high (4, 6 or 12 hours). Here's how you tell all caches to use the non-expiring cache:


   cache.defaultFactory=org.apache.roller.util.cache.LRUCacheFactoryImpl

However, if you do that, then blogs that use Roller's built-in hit counter or that display referrers will not be updated as often as your users would like. So, you might want to consider removing the #showReferrersList() macro from any themes in use on your site.

Configuring Roller's four page and feed caches

You can configure caching differently for the different types of pages and feeds produced by Roller. There are four separately configurable caches. Here are their names and an explanation of each:

weblogpages: this cache is used to cache weblog pages
weblogfeeds: this one is for weblog RSS and Atom feeds
sitewide: this is for the aggregated front-page blog and it's RSS/Atom feeds
planet: this is for feeds produced by Roller's built-in aggregator

And for each one of these caches you can configure these properties:

enabled: for debugging purposes you can completely disable a cache by setting it's enabled property to 'false'
size: sets the total number of entries allowed in a cache, each entry holds one page or feed response.
timeout: the number of seconds that an entry is allowed to remain in the cache. After this time expires the entry will be removed from the cache.
factory: set the classname of the cache factory to be used for this cache, otherwise default cache will be used

Cache property names follow the pattern cache... The best way to understand how this works is to look at the default cache configuration used by Roller:


# Weblog page cache (all the weblog content)
cache.weblogpage.enabled=true
cache.weblogpage.size=400
cache.weblogpage.timeout=3600

# Feed cache (xml feeds like rss, atom, etc)
cache.weblogfeed.enabled=true
cache.weblogfeed.size=200
cache.weblogfeed.timeout=3600

# Site-wide cache (all content for site-wide frontpage weblog)
cache.sitewide.enabled=true
cache.sitewide.size=50
cache.sitewide.timeout=1800

# Planet cache (planet feeds)
cache.planet.enabled=true
cache.planet.size=10
cache.planet.timeout=1800

The default cache configurations above are setup for a 100 weblog system. To some extent, this is guess-work. For example, we've decided to cache 4 pages and 2 feeds for each blog. That's how we arrived a cache.weblogpage.size=400 and cache.weblogfeed.size=200. And we've decided to cache blog entries for 30 minutes and feeds for one hour. That's how we arrived at cache.weblogpage.size=400 and cache.weblogfeed.timeout=3600.

You might decide to do things a little differently on your Roller system. Copy the properties above to your roller-custom.properties file and set them to values you thing are appropriate for number of weblogs, average page size, traffic levels and JVM heap size of your Roller installation.

Conclusion

Roller default cache configuration will work well without modification for a small to medium size Roller installation, but for large high-traffic sites you should increase cache sizes and think carefully about timeouts. And if you're running Roller in a cluster you might want to consider using a distributed caching system like memcached. I'll discuss that in my next HOWTO.

Latest Links: JSF vs. REST

Dave Johnson — Mon, 18 Feb 2008 13:27:08 +0000

I've been very happy with the choice of Struts 2 for Roller, but I still follow JSF because it's the Java standard. A couple of articles by Ryan Lubke about what's coming in JSF 2.0 got me thinking about JSF again.

Ryan Lubke's Blog: JSF 2.0 New Feature Preview Series, pt. 2.1: Resources
"Previous versions of JSF had no facility for serving resources"
Ryan Lubke's Blog: JSF 2.0 New Feature Preview, pt. 1: ProjectStage
"the JSF 2.0 EG has given a nod to Ruby on Rails' RAILS_ENV functionality"

One of my problems with JSF is REST. REST fans say JSF is inherently RESTless because every JSF request is a POST. JSF advocates say JSF can do GET and bookmarkable URLs if necessary and that's good enough.

Bill de hora on JSF and REST
"JSF is clearly not focused on or suitable for working in the REST style to the extent REST principles seem to be actively excluded from the design."
Gavin King on JSF and REST
"On these community sites that claim you can't build restful application with JSF. I mean it is total nonsense. It is not even remotely true."
Gavin's JSF bookmarkable URL example
In the comments thread of an anti-JSF story at The Server Side.

Fortunately, the plans for JSF 2.0 indicate that REST improvements are coming:

Java.Net TWik: JSF 2.0 Requirements Scratchpad
Mentions REST API (JSR-311) and navigation without using POST
JSR-314: JavaServer Faces 2.0
"Allow JSF application resources to be accessed via REST" and "Add support for REST (JSR 311)"

Unfortunately, it sounds like all they're planning to do is make it easier to create bookmarkable URLs and add some support for the JSF-311 REST API. Why can't the goal be to make JSF applications RESTful by default? Why can't JSF ensure that POST is only used when required by the application (not the framework) and JSF URLs are simple, clean and always bookmarkable.

Latest Links: Feb. 16, 2008

Dave Johnson — Sat, 16 Feb 2008 12:48:07 +0000

More on MySpaceâ€™s Open Development Platform - GigaOM
"made up of three APIs â€” primarily Open Social and extensions weâ€™ve added"
ZDNet.com: Progress report on the OpenSocial Web
Summary of latest OpenSocial news and hackathons from Dan Farber
Facebook to Punish Stupid Applications, Reward Good Ones - ReadWriteWeb
"Metered messaging based on user engagement could save the Facebook Platform from a growing sense of app fatigue"
Roumen's Weblog: Android plug-in for NetBeans
"the screenshots look promising"
Rob Williams' Blog: finally ditched LifeRay
"we have finally ditched Liferay in favor of JBoss Portal. So far so good. It is much more stable. The code base is not a rat's nest of untested Struts goop."
Indoor WiFi Signal Booster by Meraki
"Meraki Mini is a small, easy-to-use wireless mesh repeater."

Yahoo Weather RSS module for ROME

Dave Johnson — Wed, 23 Jan 2008 15:40:22 +0000

Apparently, I spoke to soon about ROME being in maintenance mode. There's an all-new Yahoo Weather module for ROME from Robert "kerbernet" Cooper.

ROME vs. Abdera

Dave Johnson — Tue, 22 Jan 2008 18:18:40 +0000

For Java developers starting out with RSS and Atom, here are some notes to help you figure out the differences between the Java.net ROME and Apache Abdera (incubating) projects.

ROME is a set of Java tools for parsing, fetching and generating all forms of RSS and Atom feeds. The core ROME library is relatively small and depends only on the somewhat creaky old JDOM XML parser. Available separately are modules to support various feed extensions such as OpenSearch, iTunes, GeoRSS, etc. ROME was originally developed and open sourced by Sun Portal dev team members in 2004.

ROME Propono is a subproject of ROME that supports publishing/editing entries and files to blog servers and AtomPub servers. Propono is made up of three parts: 1) a Blog Client library can publish via either the old lagacy MetaWeblog API or the shiny new AtomPub protocol, 2) an AtomPub client that publishes only via AtomPub and 3) a framework for creating AtomPub servers. Propono was developed by Ramesh Mandava and Dave Johnson, based on code from RSS and Atom in Action and open sourced as part of the Sun Web Developer Pack in 2007.

Abdera is a set of Java tools for working with Atom feeds and AtomPub protocol. This includes a parser, writers, an AtomPub client and a framework for creating AtomPub servers. Abdera's Atom feed parser uses STAX, so it uses less memory and is faster than ROME. Abdera's Atom feed support is more comprehensive than ROME's and it supports signatures, encryption, Atom to JSON, extensions for Threading, Paging, GeoRSS, OpenSearch, GoogleLogin, etc. etc. Abdera was developed by IBM and contribued to Apache in 2006.

Now let's compare frameworks. The pros and cons of ROME are:

Pro: complete RSS support, all of the dozen various flavors
Pro: it's generally simple and small, depending only one jar (JDOM)
Pro: easy to understand and use the AtomPub server framework
Pro: MetaWeblog API support
Con: Atom feed support not as comprehensive as Abdera
Con: parser uses lots of memory, slower, JDOM based
Con: community not as active, seems to be in maintenance mode (See also Ohloh stats)

The pros and cons of Abdera are:

Pro: comprehensive Atom feed support, lots more Atom extensions
Pro: faster more efficient parser
Pro: In the Apache Incubator with active and growing community (See also Ohloh stats)
Con: lots of dependencies
Con: AtomPub server framework poorly documented, overly complex (rewrite coming soon)
Con: no RSS support (there is something in Abdera contrib, but it's incomplete).

There you have it. ROME and Abdera folks: think that's a fair comparison? Are you a ROME or Abdera user? How would you like to see these frameworks move forward?

Holiday project: JMaki for Roller

Dave Johnson — Wed, 2 Jan 2008 13:12:54 +0000

Over the holidays I avoided doing anything directly related to my current set of work tasks. Sun went quiet, which helped, and I ignored the messages that piled-up in the Roller user and dev lists. It was so quiet that I had time for a fun little project: a JMaki plugin for Roller.

JMaki makes it easy to use JavaScript widgets (Dojo, Google, YUI, etc.) from PHP, JSP, JSF and now Roller. To use a widget, all you have to do is call a method or include a tag and JMaki takes care of including the right JavaScript files and generating the right HTML for you. That's not all JMaki does, there's also a pub/sub facility to make it easy to wire widgets together via events, there's a proxy for fetching remote resources common table and tree data models. The theme is cool widgets with ease-of-development and that's what I'd like to see in Roller. You can read more about the JMaki value proposition on the Why Use JMaki page.

Here's an example. Below is a Roller page template that uses two JavaScript widgest, the Dojo Clock and the YUI Data Table. All it takes is a single line of template code to include each widget, and one widget is dynamic i.e. the table is populated via an RSS feed.


    <html>
    <head><title>JMaki test page</title></head>
    <body>

        <h1>JMaki test: dojo.clock</h1>
        $jmaki.addWidget("dojo.clock")

        <h1>JMaki test: yahoo.dataTable</h1>
        $jmaki.addWidget("yahoo.dataTable", "/roller/xhp?id=rss","","")

    </body>
    </html>

And here's what that page looks like when displayed by Roller:

I'll write more about the plugin once I install it on this site. If you want some details about how the plugin was developed, you can read the email that I sent to the JMaki dev list: JMaki for Roller issues and suggestions. It links to the Java source code for the plugin.

Roller 4.0 released

Dave Johnson — Wed, 5 Dec 2007 13:16:32 +0000

Finally!

Apache Roller 4.0 has been released and is now available for download.

This is a major new Roller release which includes easier blog theme customization, a much more simple installation/upgrade process, infrastructure improvements and numerous other small fixes. You can get the release files and the official documentation via the Apache mirrors at this page:

http://roller.apache.org/download.cgi

And you can read about the new features on the What's New in Roller 4.0 page of the Roller wiki.

Project releases are approved by vote of the Apache Roller Project Management Committee (PMC). Support for a release is provided by project volunteers on the project mailing lists. Additional free support is provided by many other volunteer subscribers to the list. Bugs found in a release may be discussed on the list and reported through the issue tracker.

Roller is a Project of the Apache Software Foundation (ASF), formed by a resolution of the ASF Board of Directors. As an ASF Project, Roller is subject to the ASF Bylaws and the direction of the ASF Board. The user mailing list and issue tracker are the only support options hosted by the Apache Roller project.

Cross posted from the Roller project blog.

OpenQabal: a social software platform w/Roller

Dave Johnson — Tue, 4 Dec 2007 13:56:55 +0000

I'm always happy to see Roller used in new sites, projects and products. Here's an interesting new example that I've been meaning to blog for a while now. Phillip Rhodes is working on building what he calls OpenQabal a "social software operating system." The project integrates a set of social software applications, including Roller and JavaBB, via Single Sign-On (SSO), a common look-and-feel and Semantically-Interlinked Online Communities (SIOC). He explains it all in an lengthy and informative blog post on the project's JRoller.com blog.

I'd never heard of SIOC before. Here's the executive summary:

Semantically-Interlinked Online Communities SIOC or is a framework aimed at connecting online community sites and internet-based discussions. Currently, online communities (boards, blogs, etc.) are like islands - they contain valuable information but are not well connected. SIOC allows us to interlink these sites, and enables the extraction of richer information from various discussion services.

Sounds like it could be pretty darn useful. But then again, I spent a little time exploring the list of SIOC enabled sites with the SIOC Firefox plugin and didn't really find any examples of interlinked communities or conversations. Am I missing something?

Sun open source project governance

Dave Johnson — Sat, 1 Dec 2007 13:57:03 +0000

Here's a sampling of governance docs from some of Sun's many open source projects. I've listed them in order of what I feel to be, the most progressive (i.e. community governance) to least progressive (i.e. corporate control). I've also listed a key quote from each doc and made a brief comment about each.

OpenSolaris governance: "The OpenSolaris Community has the authority and responsibility for all decisions" - seems to approach ASF style governance.

OpenJDK interim governance: "The [board] shall be comprised of [5 and ] shall conduct its affairs in accordance with democratic principles and shall represent the interests of the Community. Two [members] shall be employees of Sun" - not final, but looking good.

Netbeans governance: "In the case of an irresolvable dispute, there is a governance board of three people, who are appointed for six month terms." (2 appointed by community, 1 by Sun)." - sounds pretty good, but the doc seems a little vague.

SunGrid governance: "The Board positions include the Community Leader, the Community Site Manager, and four general members, two Sun members and from the independent developer Community." - sounds good, again doc seems a little vague.

Glassfish governance: "The GlassFish project has an overall Project Lead ... appointed by Sun" - Sun has final say.

OpenSSO governance (draft): "Project Managers make the final decision ... are appointed by Sun" - Sun has final say.

OpenDS governance: The OpenDS project has single, overall Project Lead [who is] appointed by Sun Microsystems." - Sun has final say.

Mobile and embedded: "Sun may change its appointed Governance Board members at any time" - Sun has final say.

Looks to me like the trend is towards community governance and the most important projects are the ones getting the most attention and the most progressive governance. That's good and I sincerely hope the trend continues.

Apache Shindig voting in progress and more OpenSocial details emerge

Dave Johnson — Fri, 30 Nov 2007 12:48:25 +0000

I wrote about Shindig before, it's a new open source project to implement the Google OpenSocial APIs. Well, now the official voting to accept the Shindig project into the Apache Incubator is in progress and some interesting details have emerged in the latest version of the proposal. First, as you can see by the initial list of committers in the proposal Google has joined the Shindig effort in force. Second, the proposal says that Shindig will be the reference implementation of the OpenSocial APIs. And third, Shindig will not only include the client-side JavaScript container but also a Java back-end. Brian McAllister has already made some "gnarly" initial client-side container code available, I can't wait to see the Google contribution.

Groovy support back in Netbeans

Dave Johnson — Wed, 28 Nov 2007 09:05:28 +0000

After going missing in NB 5.5, Groovy support is back in Netbeans. Basic Groovy support with syntax coloring and support for running scripts from the IDE is available in plugin form (download page) for Netbeans 6.0 (starting with RC2), read about it on Geertjan's blog.

Here's what's coming after Netbeans 6.0, Groovy project support:</>

After Netbeans 6.0, the story gets better. Geertjan writes that a brand new Groovy plugin will be available in the post-6.0 builds that adds support for three types of Groovy projects: applications, class libraries and Grails webapps.

Roller Strong #11

Dave Johnson — Tue, 27 Nov 2007 21:04:43 +0000

I've got a couple of Roller related items to blog about, so why not just call it Roller Strong #11.

First, Lars Trieloff responds to some of the questions I raised about JCR and Roller in my ApacheCon wrap-up post. I left a comment on his blog in response. Personally, I think a JCR back-end is a very interesting idea and I wish I had some more time to explore it.

Manchi Leung AKA Thinkboy posted the code for a new Textile plugin to the Roller dev list, using Textile-J. Thinkboy says "it supports almost all of the Textile syntax. very much the same as Confluence wiki. Now I can easily sync or copy working notes from Confluence wiki to my personal Roller blog." Nice. Note to self: I need to fix up some of our existing entry plugins -- I think some of them (e.g. Ekit) still haven't been updated for Roller 3.1.

Arun Gupta blogged recently about Backing up your Roller entries and explained how to use the Grabber example (now known as BlogBackup in Blogapps 2) from the Blogapps project to backup your Roller blog. Backing-up your entries, but backing up your uploads is not. Hopefully, blogs.sun,com will turn on Atom protocol someday and that'll will make it easy for a tool like Grabber backup both entries and uploads.

We're still waiting on Roller 4.0, but I sense our wait is soon over. Roller 4.0 RC10 was released one week ago with just a couple of bug fixes. And so far, no critical issues have been found. We've got only one +1 vote (thanks Anil!) so far so committers please test and vote.

And finally, I have to mention MarkMail because I've been using it throughout this blog post. MarkMail provides a slick interface and excellent facilities for mailing lists of all kinds. They're indexing all of the Apache mailing lists and providing statis and charts for each. Check the Roller page at MarkMail for example.

That's all I've got for this go-round. Keep on rollin'

Latest Links: Android, OpenSolaris and misc.

Dave Johnson — Mon, 26 Nov 2007 17:00:03 +0000

Roy Fielding [ogb-discuss]: please dissolve the Desktop Community
"there is absolutely no reason for this organization to exist if all decisions are going to be made by Sun."
Ian Murdock [ogb-discuss]: re: please dissolve the Desktop Community
"You have to be joking? I don't even know where to begin.. This is like Robert's Rules of Order run amok"
Jim Grisanzio: Two Great Linus Quotes
"(1) one person or company shouldn't control the entire community, and (2) the real value of community development comes over the long term and results from many small contributions, not one big one."

Ed Burnette: Sun/Google Android â€œfightâ€ overblown
"Iâ€™m here to tell you, itâ€™s all bunk"..."However Google did make one big mistake with Android"
Slashdot: Google, Sun Headed for Showdown Over Android
Pure FUDtastic speculation based on Stefano's blog post
robilad: QOTD: Google's license for the Android SDK
"you may not extract the source code or create a derivative work of the SDK"
Javalobby: Is Google the New Microsoft?
Dalibor's comment: "Google will keep Android as proprietary as they can for as long as they can, while letting people believe something else"

David Heffelfinger: Eclipse Veteran Switches To NetBeans
"NetBeans has now surpassed Eclipse in usability. Count me in as a new convert."
Stuck in the middle : Weblog
Rickard Oberg is blogging at JRoller.com again
Alan Burlison's Blog: How to leave Facebook
"try mailing them, quoting the clear precedent they have set by closing my account"
Symphonious Â» Why Support OpenSocial?
"However, if OpenSocial gets support outside social networks it has the possibility of attracting developers who actually care about their users, not just their advertising profits and install count"
ZDNet: Firefox 3 Beta 1 has landed
"Improved performance with more than 300 memory leak fixes."

ApacheCon US 2007 wrapup

Dave Johnson — Tue, 20 Nov 2007 17:42:51 +0000

I spent last week at the ApacheCon US 2007 conference in Atlanta, Georgia. Here's a write up of some of my experiences there.

The Hackathon

The Hackathon is a two day event. For those who don't know what a hackathon is, I'll explain how it works. A room with about 20 large round tables, wireless internet and plenty of power strips is provided. Folks show up, plug-in, start working and chatting with each other about projects and other random topics. Sometimes they cluster by project, Struts guys around one table and Geronimo guys at the next, but usually there's a good mix at each table. Sometimes groups have specific goals like "ship version 2.0" in mind, but usually folks are just working, sharing knowledge and getting to know each other. At various times pizza, soda, breakfast pastries, beer, coffee and/or wine is carted into the room -- so there's not much reason to leave except for things like fresh air, sunlight and sanity.

I had a couple of interesting conversations at the Hackathon. I spent some time talking to Brian McAllister about his Shindig proposal, which I've already mentioned. I also spoke with David Jencks about getting better Role Based Access Control (RBAC) in Java EE to support social software like blogs, wikis and social network applications because static roles hard-coded into web.xml just won't do.

Roller and the Roller/Struts2 BOF

As usual, I attended ApacheCon to promote and represent Roller and I did so in my talk, at the Roller/Struts 2 BOF, at the Sun booth and wherever else I could. As I mentioned before, my talk on Roller and blogs as a web development platform went well. I had updated my talk to include an example of how to post to a blog using Abdera and I urged folks to stick around for Garrett Rooney's Abdera talk, which followed mine in the same room.

The BOF session also went well. Matt Raible and Don Brown organized the session and all I had to do was show up and enjoy the good company and the Atlassian provided beer, wine and nibbles. About ten people showed up and we talked about a variety of topics including user management in Roller, the growing similarity of Struts 2, Spring MVC and other Java web frameworks and then my wife dragged me away from the fun. By the way, Don works for Atlassian on the new JIRA Studio suite, which, I believe, is going to give Collabnet, SourceForge Enterprise and even the likes of IBM Jazz and Microsoft Team System some serious competition.

Roller the Java Content Repository (JCR) API

The idea of using a content management system to store Roller content keeps on coming up. At ApacheCon EU earlier this year, I spent some time talking to Lars Trieloff (who now works for CMS vendor Day Software) about implementing the Roller back-end interfaces using the Java Content Repository (JCR) APIs instead of the Java Persistence API (JPA) that we use now. At this ApacheCon, Noel Bergman brought up the topic a couple of times and pointed out that Day Software, has blog and wiki modules that are both backed by JCR. We could do the same thing: create version of Apache Roller and Apache JSPWiki (incubating) that share the same content repository.

Later, Jukka Zitting (who also works for Day Software), suggested the idea of implementing JPA itself with JCR, thus allowing Roller to store its content in a CMS in a totally transparent fashion. This topic is interesting to me, but I don't fully understand the benefits of backing blogs and wikis with JCR. What new use cases would this support? How do the interesting features of JCR, like versioning for example, bubble up through Roller -- especially if Roller is to support both RDBMS and CMS back-ends?

And by the way, Day is not the only company building interesting products around JCR and the Apache Jackrabbit JCR implementation. Hippo CTO ArjÃ© Cahn and others from Hippo were present at ApacheCon, talking about their CMS product and related Apache projects.

The REST sessions and the Struts 2 REST plugin

Thursday afternoon there was series of REST talks, starting with Roy Fielding father of REST, then Sanjiva Weerawarana defender of WS-*, Dan Diephouse and Don Brown. Roy's talk was standing room only and the other REST talks were quite popular as well. Hearing from REST masters as great, but Don's talk was the one most relevant to my work (since I'm a Struts 2 user).

Don talked about the new REST plugin he has developed for Struts 2, which looks like a wonderful thing. It builds on the existing CodeBehind plugin to give you Ruby-on-Rails like convention-over-configuration and in most cases no Struts configuration or properties files are necessary. From my point-of-view, it's just another reason to choose Struts 2 over JSF, which, as Bill de hÃ“ra points out, "is clearly not focused on or suitable for working in the REST style to the extent REST principles seem to be actively excluded from the design." See also: Matt Raible's notes on the Struts 2 REST plugin and Don's slides (a zipped PDF file).

Lucene and search sessions

On Friday there was a series of talks related to Apache Lucene and related projects such as Solr. These talks seemed to be quite popular as well. I attended the Solr talk. Apache Solr is a version of the Lucene search engine that is packaged as an easy to install and easy to use web application. The talk demonstrated all of the things you can do with Solr without writing any Java code and it was pretty impressive. I also spoke with Ken Krugler of Krugle, the source code search engine, about search in Roller, something that he's been thing and writing about lately.

Couple of end notes re: Atlanta

First, the venue. The Westin is an impressive building, it's the tallest hotel in the western hemisphere and the rotating bar and restaurant at the top are a lot of fun, with relatively good food and well worth a visit. The hotel itself, though, does not seem to be all that well managed or maintained. The carpets are a little spotty and the furniture is a little worn. Generally, that kind of stuff doesn't bother me much, but I can see why folks might complain (and they did).

Second item: a good dining experience. On Monday night, a big group of hackathon attendees ventured out to look for Rare, billed as a soul-food tapas restaurant. It was quite a long walk from the Westin but we managed to get there with help from Greg Stein's iPhone and some overly helpful folks we ran into on the street. Rare was simply wonderful so next time you're in Atlanta, skip Pittypat's Portch and give Rare a try instead.

And third, MARTA. The travel info I received from the ApacheCon folks recommended taking a shuttle bus from the airport to the Westin, but that's not the best way to go. The MARTA train is a much better way to go -- $4 for a the round trip, it's quick and there's no need to tip.

Wrapping up

That brings me to the end of my notes, so it's time to wrap up. As usual, ApacheCon was a great experience and I hope to make it to the next one in Amsterdam this coming April.

One more thing. You can find many of the session slides on the ApacheCon wiki.

Roller and blogs as a web dev. platform presentation

Dave Johnson — Wed, 14 Nov 2007 17:09:31 +0000

I just posted the slides for my ApacheCon US 2007 talk on the ApacheCon wiki. It's basically the same talk that I gave at ApacheCon EU earlier this year, but I spent some time tweaking the slides, simplifying removing unnecessary bits and adding a little Abdera coverage. That, and the fact that the power did not fail, seemed to make the talk go more smoothly this morning. Here are the slides:

Apache Roller and blogs as a web development platform (2MB PDF)

Latest links Nov. 12, 2007: Glassfish, OpenSocial and more

Dave Johnson — Mon, 12 Nov 2007 07:23:08 +0000

Sound Opinions from Chicago Public Radio and American Public Media
Best podcast ever

The Aquarium: GlassFish Interim Governance Board - Now Complete
"The complete roster is Tony, Greg Luck (Wotif.com) and Pierre Delisle (Google), and Simon and myself (Sun)"
Bistro!: GlassFish/SJS AS in production - which bundle, which profile, ...?
Explains differences between developer, cluster and enterprise profiles
GlassFish Podcast: The GlassFish Podcast
Finally, a Glassfish podcast! Props to Alexis Moussine-Pouchkine
Apple - Downloads - UNIX & Open Source - GlassFish
Download Glassfish V2 directly from Apple
Red Hat and Sun Collaborate to Advance Open Source Java Technology
"Red Hat has signed Sun's broad contributor agreement that covers participation in all Sun-led open source projects."

Megginson: First looks at OpenSocial: part 1 (URLs)
Lists the URIs for the AtomPub collections available in OpenSocial
Megginson: First looks at OpenSocial: part 2 (members and friends)
How OpenSocial members and friends are represented in Atom format
Megginson: First looks at OpenSocial: part 3 (activities)
How OpenSocial activities are represented in Atom format and manipulated via AtomPub protocol
Megginson: First looks at OpenSocial: part 4 (persistence data)
How OpenSocial persistence is implemented via AtomPub protocol
Google: OpenSocial Container Sample
Shows "basic demonstration-level OpenSocial container can be implemented"
Dare Obasanjo: OpenSocial Tech. Overview and Critique
"Despite these misgivings, I think this is a step in the right direction. Web widget and social graph APIs need to be standardized across the Web."

snellspace.com: Notes, Part 2
"lots and lots of things that can be modeled as collections of web resources"
netzooid: Building Services with AtomPub
"While APP is not the one true protocol, I think I?m hooked"

Ten types of plugins supported by Roller 4.0

Dave Johnson — Wed, 17 Oct 2007 10:12:31 +0000

<a href="http://cwiki.apache.org/confluence/display/ROLLER/What%27s+New+in+Roller+4.0 "> I'm working on documenting the Roller plugin system, comparing it to similar systems (e.g. Wordpress and Confluence) and coming up with some proposals for improvements. As part of that work, I've come up with a list of the plugin types supported by Roller 4.0:

Page Model Plugin (Interface: PageModel)
Allows you to make new objects available to Roller page templates, providing a way to display external data in the blog pages and feeds generated by Roller.
Weblog Editor UI Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/ui/core/plugins/WeblogEntryEditor.java?view=markup"> WeblogEntryEditor)
Plugin your own Rich Text or other type of editor into the New/Edit Entry page in the Roller web UI. Roller comes with two such plugins: a plain-text editor and a rich-text editor based on Xinha.
Weblog Entry Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-business/src/main/java/org/apache/roller/weblogger/business/plugins/entry/WeblogEntryPlugin.java?view=markup"> WeblogEntryPlugin)
Allows you to transform weblog entry content at the time it is displayed in a weblog page or a feed. Once you've installed your entry plugin, blog authors can enable and disable it on a per entry basis. For example, if you've got the Wiki Plugin installed then bloggers can choose to blog using wiki syntax and the plugin will transform the wiki syntax to HTML on display.
Weblog Entry Comment Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/business/plugins/comment/WeblogEntryCommentPlugin.java?view=markup"> WeblogEntryCommentPlugin)
Allows you to transform comment content at the time it is displayed in a weblog page or feed. By default, Roller uses a link-markup plugin to turn URLs into clickable links, an auto-format plugin to add paragraph breaks and a safe-subset plugin to strip out all but the safest HTML tags. You can add new comment formatter plugins or replace the existing ones.
Comment Authenticator Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/ui/rendering/plugins/comments/CommentAuthenticator.java?view=markup"> CommentAuthenticator)
Plugin your own comment authenticator to replace the math-question test used in most Roller blogs. Allows you to add some additional HTML to the comment form and some server-side logic for authenticating comment posts. You could add a CAPTCHA test this way, but I'm not sure there's enough pluggability to support OpenID authentication.
Comment Validator Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/apps/weblogger/src/java/org/apache/roller/weblogger/ui/rendering/plugins/comments/CommentValidator.java?view=markup"> CommentValidator)
Allows you to add additional comment spam filters to Roller. Your filter can examine each comment posted and report to Roller whether it appears to be spam or not. Roller includes an Akismet validator, a too-many-links validator and a trackback validator.
Renderer Plugin (Interfaces: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/ui/rendering/RendererFactory.java?view=markup"> RendererFactory and <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/ui/rendering/Renderer.java?view=markup"> Renderer)
Allow you to plugin a renderer for a specific template language name. Roller's stock templates and theme all use the Velocity template language, but by plugging in your own renderer you can author templates in whatever JVM based language you wish. For example, plugins exist for authoring Roller templates in JavaScript, JRuby and Groovy Server Pages (GSP) languages.
Request Mapper Plugin (Interface: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-web/src/main/java/org/apache/roller/weblogger/ui/rendering/RequestMapper.java?view=markup"> RequestMapper)
Allows you to plugin to Roller's URL structure and request handling system, like adding a Servlet but not requiring you to edit web.xml.
Cache system Plugin (Interfaces: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-business/src/main/java/org/apache/roller/weblogger/util/cache/CacheFactory.java?view=markup"> CacheFactory and <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-business/src/main/java/org/apache/roller/weblogger/util/cache/Cache.java?view=markup"> Cache)
Plugin your own cache system to replace or augment Roller's in-memory cache system. For example, you might want to plugin memcached as your distributed page/feed cache as Sun does for blogs.sun.com.
Repeatable Task (Classes to extend: <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-business/src/main/java/org/apache/roller/weblogger/business/runnable/RollerTask.java?revision=559911&view=markup"> RollerTask or <a href= "http://svn.apache.org/viewvc/roller/trunk/weblogger-business/src/main/java/org/apache/roller/weblogger/business/runnable/RollerTaskWithLeasing.java?revision=559911&view=markup"> RollerTaskWithLeasing)
Roller runs a number of tasks behind the scenes and you can add your own tasks and configure when they start and how often they run. There's also a lease-system for working in a distributed environment.

UPDATE: The Advanced Roller presentation from ApacheCon EU 2008 covers many of the different types of plugins above and gives examples, configuration tips, etc.

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?

Blogapps 2.1 released

Dave Johnson — Tue, 2 Oct 2007 21:49:40 +0000

<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.

ROME Propono 0.6 released

Dave Johnson — Mon, 1 Oct 2007 11:20:19 +0000

The first release to discuss is ROME Propono, which includes a ROME based Atom protocol client library, Atom protocol server framework and an Blog Client library abstraction that supports both Atom protocol and the MetaWeblog API.

I've been working on Propono 0.6 off-and-on since May, keeping it in sync with the latest version of the Atom protocol, testing it against Tim Bray's APE and adding various improvements needed in my other projects. Over the weekend I finally had enough time to get a release out. You can find the full-details at the link below but basically this release adds support for the final Atom Publishing Protocol specification and better support for relative URIs.

What's next? Once ROME 1.0 is released Real Soon Now, I'll get a another release out and I'll probably call it ROME Propono 1.0.

re: JSPWiki@Apache?

Dave Johnson — Tue, 18 Sep 2007 22:26:13 +0000

Congrats are also in order for the JSPWiki team. As Janne Jalkanen notes, JSPWiki was accepted into the Apache Incubator yesterday. I'm proud to be one of the four mentors who will guide the project through the incubation process. Janne and the JSPWiki team put together a great proposal and I think it was clear to everybody involved in the vote that these folks know what they're doing. They'll master the Apache way in no time.

Switched

Dave Johnson — Tue, 18 Sep 2007 21:46:20 +0000

Yes this is my obligatory Glassfish V2 post but listen, for me V2 is a pretty big big deal. Like Eclipse, which was the IDE that pulled me away from VIM, Glassfish V2 is the app server that finally pulled me away from Tomcat.

You see, I've been using Tomcat every day for a very long time. I started back in 2000 when I worked at HAHT Software and I was working on the new "Rocketsled" J2EE version of the HAHTsite app server. We were ripping out the old proprietary page engine and plugging in Tomcat. It was a pleasure to work with and I learned a hell of a lot from the code-base. After joining Sun and switching from Eclipse to Netbeans because Sun-on-Sun matters, I still stuck with Tomcat. It's what we were using for blogs.sun.com and Glassfish was just too bulky and slow. I grew to love Netbeans, but I couldn't stomach Glassfish, until now.

Now that Glassfish V2 is out I'm switching from Tomcat to Glassfish for all of my development. It's more than fast enough. With Glassfish on my MacBook Pro, Roller restart time is about 8 seconds compared to 16 with Tomcat. And the quality is high; the admin console, the asadmin command-line utility and the docs are all excellent. The dog food is surprisingly tasty ;-)

Congrats to the Glassfish team!

ApacheCon US 2007 - still time to be an early bird

Dave Johnson — Fri, 7 Sep 2007 18:48:10 +0000

ApacheCon is coming up fast. I just faxed in my speaker's agreement and I'm starting to update my talk to cover the latest changes in the upcoming Apache Roller 4.0 and 4.1 releases.

I've been four times now and ApacheCon is always a great conference. It's small and cozy enough, but almost all of the Apache projects are represented. So it's easy to find the experts, make new friends and get all of your questions answered. The session line-up looks great this year; here are ones that caught my eye:

Hacking Atom with Apache Abdera - Garret Rooney
A little REST and Relaxation - Roy Fielding
WS-* vs. REST: Facts, Myths and Lies - Sanjiva Weerawarana
Go Light with Apache Struts 2 and REST - Don Brown
How to Run a Business Around The ASF - Sanjiva Weerawarana
Open Source Community Anti-Patterns - Ted Leung
RIAs using Apache Derby and Comet - Jeanfrancois Arcand & Francois Orsini
Apache Derby - Saucer Separation - Rick Hillegas
JCR in Action - Content-based Applications with Apache Jackrabbit - Carsten Ziegeler

Want to go? There's still time to shave a couple of hundred dollars off the conference fees by registering early. Early bird pricing has been extended to Sept. 22, 2007.

And the Weston looks like a pretty nice place for a conference:

ApacheCon US 2007 | Register here
November 12-16, 2007
Westin Peachtree Plaza
Atlanta, Georgia