Posts tagged 'java'



Upgraded to Roller 6.1.1

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

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.

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

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

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

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

Diagram.
Figure 5: Incoming request for Edit-Bookmark page

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

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

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

  3. The BookmarkFormAction calls the BookmarkManager to retrieve the bookmark information that is to be edited.

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

  5. The BookmarkFormAction finally forwards the request to edit-bookmark.jsp so that the page may be rendered.

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

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

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

  2. The Struts Controller Servlet populates the BookmarkForm bean with data from the incoming request.

  3. The Controller calls the BookmarkFormAction and passes in the form bean.

  4. The BookmarkFormAction retrieves the data from the BookmarkForm bean.

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

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

Castor

Struts

Velocity

XDoclet

Originally published here: http://onjava.com/onjava/2002/04/17/wblogosj2ee.html


Talking Usergrid at ApacheCon 2014

ApacheCon 2014

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

O'Reilly logoTen 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:

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

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

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)

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

[Read More]

Roller 5 and Glassfish 3

Duke and GlassFishIn 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.

[Read More]

Built with Maven

Maven Logo

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

photo of beginner's guide to Apache Roller 4.0

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

Crammed into one post...

After a month of blog neglect, my automatic Latest Links from my Delicious.com account started to pile up. Back in the glory days of this blog, I blogged about things instead just saving links or tweeting about them. 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.  [Read More]

RSC 2009: connecting developers and community

RSC logo

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

Connections logo

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.

Jazz logo

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

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. [Read More]

ROME 1.0 RC2 on the way

Nick's Twitter icon

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?

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

Atom logo

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

oneway We want Project SocialSite to have a Flexible Relationship model that a site operator can tweak to suit the unique requirements of the 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. [Read More]

CommunityOne call for papers is open X 2

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.

c1

Details of Roller setup at blogs.sun.com

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

diagram

Another vote for RESTful JSF

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

Main | Next page »