Atif's Technology Musings

Is RIFE dead?

2009-04-28T09:52:00.000-04:00

I wrote a blog entry in April 2007 about RIFE. It has been 2 years since I wrote that entry. I had mentioned that RIFE was lacking in documention and the learning curve was pretty steeep. That was one of the resons why I decided not to investigate further. Geert tried to calrify some of the questions I had, but that didn't really remove all the doubts I had. I know that Geert has moved on to bigger and better things. The framework seems to be dead now as there hasn't been any new releases since 2007. This goes to show that with too much complexity, it is very difficult to build a community that can sustain the project beyond the original founders. It was a framework built on some very good concepts and I am sad to see it go. I do see some nightly snapshots, but no new releases. Is RIFE really dead?

KDE free and happy

2009-01-17T13:24:00.000-05:00

I wrote in a previous post from October 20008 that I was very unhappy with the direction of KDE. The Kubuntu Intrepid was about to be released with KDE 4 as the default desktop. I got a lot of responses saying that I could still continue using KDE 3.x or I should switch to another distro like OpenSuse. Neither of those were really feasible options as I didn't want to be stuck on KDE 3.x and switching distro was even more a radical change.

When Kubuntu Intrepid released, I downloaded it and gave it a try. I knew immediately that I could no longer use it as my desktop. It was sluggish and not very user friendly. I promptly switched to Ubuntu Intrepid with Gnome desktop. I must admit that Gnome implementation in Ubuntu feels a lot more tightly integrated than KDE was in Kubuntu.

I did have to adjust myself to Gnome initially. As an example, I was very fond of Superkaramba on KDE. Gnome does have comparable desklet and screenlet implememtations. But they just do not seem as seemless as Superkaramba. So, I decided to stick with regular panel applets and I must admit that I somehow like them better than full fledged Superkaramba widgets. This could be true with Gnome in general as everything seems intuitive and simple. Gnome doesn't try to emulate Windoze like KDE. I got the native drivers for the Nvidia card installed and now have Compiz enabled. So, now I have the simplicity of Gnome with added 3D effects. It's not a scientific observation, but the memory management also seems better on Gnome than KDE.

The moral of the story is that I am KDE free and happy.

Is this the end of KDE for me?

2008-10-19T09:04:00.000-04:00

I have been a linux user since early days. In fact for home use I only have Linux and Mac OSX. I have used RedHat, Fedora and Mandrake/Mandriva in the past. Then I discovered Ubuntu few years back and it’s been no looking back. I have used both Ubuntu and Kubuntu extensively. But my destop of choice for home computer has been Kubuntu as I have alwyas felt that KDE has better tooling than GNOME. I like the simplicity of GNOME, but KDE always had more applications.

I love how KDE evloved and matured in 3.x versions. But, then I think the focus shifted to make it look and behave more like Windows (especially Vista with Plasma L&;) for version 4. That’s where my frustration with KDE comes from. I have given it a try a number of times since early beta days and I have been disappointed every single time. My main frustrations have been:

It’s horribly slow compared to 3.x versions.

It takes more memory to run. In fact it pretty much takes same memory as you would require for Windows XP.

The Desktop is ugly. I am pretty happy some simple icons on the desktop. I don’t need fancy effects. There is a value in simplicty and I wish KDE devleopers learnt this from Mac OSX.

I have been using Superkaramba for a long time and love it compared to KDE applets. In version 4, these are replaced by widgets. It just seems like a step in wrong direction as it has fewer widgets and they are horrible.

Every time I tried to customize the desktop and L&F, it ended up screwing up everything.

The main KDE menu is almost unusable. I don’t understand how it is more user friendly

Same applies to Dolphin file manager. I have Dolphin on KDE 3.x as well, but again there isn’t anything mind blowing.

The release of Ubuntu 8.10 is almost here and Kubuntu is going to make KDE 4 as the default desktop. I am seriously considering switching to GNOME or Xfce going forward. The purpose of a desktop is make the life easier for a user and that has not been my impression of KDE 4. May be GNOME was right all along in the philosophy of keeping things simple and usable.

POX (Plain Old XML) JAX-WS service using CXF and Spring Configuration

2008-01-01T15:22:00.000-05:00

The new and upcoming Apache CXF framework is quickly gaining steam and rightfully so. It's very intuitive, simple to use and functional. Some of it comes from the fact the its roots are in popular XFire and Celtix frameworks. It's still in the incubation stage at Apache but the current releases are pretty stable. The documentation is not complete right now, but it's improving as well.

One of the cases where I found the document and example lacking is the POX (Plain Old XML) service using JAX-WS Provider model and configuring it using Spring. The examples are mainly focussed towards configuring and starting the service from Java code. So, I created this simple EchoService example that shows step by step how to do it.

First step is to create the service Java class that will echo the incoming XML message back to the requester. We will also annotate this class using the JAX-WS annotation to mark it as a web service provider and the message type to be the payload. So, the CXF implementation knows that it should only deliver the message payload to the service class. The CXF binding layer processes any binding level wrappers and headers.


/**
 * EchoService.java Jan 1, 2008
 */
package test.jws.provider;

import javax.xml.transform.dom.DOMSource;
import javax.xml.ws.Provider;
import javax.xml.ws.Service;
import javax.xml.ws.ServiceMode;
import javax.xml.ws.WebServiceProvider;

/**
 * <p>
 * A sample EchoService POX service using the JAX-WS Provider interface.
 * </p>
 * @author Atif Khan
 * @since Jan 1, 2008
 */
@WebServiceProvider()
@ServiceMode(value = Service.Mode.PAYLOAD)
public class EchoService
  implements Provider<DOMSource>
{

  /**
   * <p>
   * Process the incoming DOM request and echo it back.
   * </p>
   * @param request
   *          DOMsource representing the request source
   * @return DOMsource representing the response source
   * @see javax.xml.ws.Provider#invoke(java.lang.Object)
   */
  public DOMSource invoke( DOMSource request )
  {
    System.out.println( "EchoService received the POX request." );

    return request;
  }

}

In the above class we specified that we want to receive the incoming XML message as DOM. You can change it to use any concrete subclass of the Source interface (e.g. SAXSource).

Next step is to create the Spring configuration. For simplicity sake, let's keep the name of this file to applicationContext.xml. Here is an example:


<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:jaxws="http://cxf.apache.org/jaxws"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

  <import resource="classpath:META-INF/cxf/cxf.xml" />
  <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
  <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
  <import resource="classpath:META-INF/cxf/cxf-extension-xml.xml" />
  <import resource="classpath:META-INF/cxf/cxf-extension-http-binding.xml" />

  <jaxws:endpoint id="echoService" implementor="test.jws.provider.EchoService"
    address="/echo" bindingUri="http://www.w3.org/2004/08/wsdl/http">
    <jaxws:serviceFactory>
      <bean class="org.apache.cxf.jaxws.support.JaxWsServiceFactoryBean">
        <property name="wrapped" value="true" />
      </bean>
    </jaxws:serviceFactory>
  </jaxws:endpoint>
  
</beans>

The key things to notice in the above XML are:

Address of the service (/echo).
Binding URI (http://www.w3.org/2004/08/wsdl/http). This is really important. This is what tells CXF that this service is going to be simple XML over HTTP.

Declaration of service factor where we indicate that the messages are going to be of wrapped nature

All that's remaining is to declare the Spring context listener in your web.xml for the web application that this service is going to be a part of. Here is an example of the web.xml:


<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
         version="2.4">

  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <servlet>
    <display-name>CXF Servlet</display-name>
    <servlet-name>CXFServlet</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>CXFServlet</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
</web-app>

As you can see that there is nothing special here at all. It's all standard Spring configuration using the context loader listener. Also, we are declaring the CXF servlet here and mapping it to /* to make all the requests to this web application go through the CXF servlet.

Now all you have to do is to package this web application and deploy it in your favorite application server. You should be able to access the Echo Service we wrote at http://localhost:8080/AppName/echo (you will have to adjust the port and application name in the URL). Now HTTP post a XML to this URL and you should get the request echoed back to you.

Maven POM
I think it's more useful to also specify the Maven POM that contains all the dependencies as well to build the run this example. Please keep in mind that some of the dependencies here may not be required anymore as I was playing around with a lot of CXF functionalities.


 < ?xml version="1.0" encoding="UTF-8"?>
 <project>
   <modelversion>4.0.0</modelversion>
   <groupid>CXFTest</groupid>
   <artifactid>CXFTest</artifactid>
   <packaging>war</packaging>
   <version>0.0.1</version>
   <repositories>
     <repository>
       <id>apache.incubating.releases</id>
       <name>
         Apache Incubating Release Distribution Repository  
       </name>
       <url>
         http://people.apache.org/repo/m2-incubating-repository  
       </url>
     </repository>
   </repositories>
   <properties>
     <spring .version>2.0.7</spring>
     <cxf .version>2.0.3-incubator</cxf>
   </properties>
   <dependencies>
     <!--
     Spring is directly included to override the version 2.0.4 cxf 
     brings in its own dependencies.  This is not strictly necessary but
     just being shown to let you know how this is done.
     -->
     <dependency>
       <groupid>org.springframework</groupid>
       <artifactid>spring-core</artifactid>
       <version>${spring.version}</version>
     </dependency>
     <dependency>
       <groupid>org.springframework</groupid>
       <artifactid>spring-beans</artifactid>
       <version>${spring.version}</version>
     </dependency>
     <dependency>
       <groupid>org.springframework</groupid>
       <artifactid>spring-context</artifactid>
       <version>${spring.version}</version>
     </dependency>
     <dependency>
       <groupid>org.springframework</groupid>
       <artifactid>spring-web</artifactid>
       <version>${spring.version}</version>
     </dependency>
     <dependency>
       <groupid>log4j</groupid>
       <artifactid>log4j</artifactid>
       <version>1.2.14</version>
     </dependency>
     <!-- Depending on your requirements you may need more or less modules from cxf -->
     <dependency>
       <groupid>org.apache.cxf</groupid>
       <artifactid>cxf-rt-core</artifactid>
       <version>${cxf.version}</version>
     </dependency>
     <dependency>
       <groupid>org.apache.cxf</groupid>
       <artifactid>cxf-rt-frontend-simple</artifactid>
       <version>${cxf.version}</version>
     </dependency>
     <dependency>
       <groupid>org.apache.cxf</groupid>
       <artifactid>cxf-rt-frontend-jaxws</artifactid>
       <version>${cxf.version}</version>
     </dependency>
     <dependency>
       <groupid>org.apache.cxf</groupid>
       <artifactid>cxf-rt-databinding-aegis</artifactid>
       <version>${cxf.version}</version>
     </dependency>
     <dependency>
       <groupid>org.apache.cxf</groupid>
       <artifactid>cxf-rt-transports-local</artifactid>
       <version>${cxf.version}</version>
     </dependency>
     <dependency>
       <groupid>org.apache.cxf</groupid>
       <artifactid>cxf-rt-transports-http</artifactid>
       <version>${cxf.version}</version>
     </dependency>
     <dependency>
       <groupid>org.apache.cxf</groupid>
       <artifactid>cxf-rt-transports-http-jetty</artifactid>
       <version>${cxf.version}</version>
     </dependency>
     <dependency>
       <groupid>org.apache.cxf</groupid>
       <artifactid>cxf-rt-transports-jms</artifactid>
       <version>${cxf.version}</version>
     </dependency>
     <dependency>
       <groupid>org.apache.cxf</groupid>
       <artifactid>cxf-rt-management</artifactid>
       <version>${cxf.version}</version>
     </dependency>
     <dependency>
       <groupid>org.apache.cxf</groupid>
       <artifactid>cxf-common-utilities</artifactid>
       <version>${cxf.version}</version>
     </dependency>
     <dependency>
       <groupid>org.mortbay.jetty</groupid>
       <artifactid>jetty</artifactid>
       <version>6.1.5</version>
     </dependency>
     <dependency>
       <groupid>junit</groupid>
       <artifactid>junit</artifactid>
       <version>3.8.2</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupid>org.apache.cxf</groupid>
       <artifactid>cxf-rt-bindings-http</artifactid>
       <version>${cxf.version}</version>
     </dependency>
   </dependencies>
   <build>
     <plugins>
       <plugin>
         <artifactid>maven-compiler-plugin</artifactid>
         <configuration>
           <source>1.6</source>
           <target>1.6</target>
         </configuration>
       </plugin>
     </plugins>
   </build>
 </project>

Here is a list of all the jar files that ended up being in the war file from the build using above Maven POM. Again, some of the jars here may not be needed.

XmlSchema-1.3.2.jar jaxb-impl-2.0.5.jar
aopalliance-1.0.jar jaxb-xjc-2.0.jar
avalon-framework-4.1.3.jar jaxen-1.1.jar
commons-lang-2.1.jar jaxws-api-2.0.jar
commons-logging-1.1.jar jdom-1.0.jar
cxf-api-2.0.3-incubator.jar jetty-6.1.5.jar
cxf-common-schemas-2.0.3-incubator.jar jetty-util-6.1.5.jar
cxf-common-utilities-2.0.3-incubator.jar jra-1.0-alpha-4.jar
cxf-rt-bindings-http-2.0.3-incubator.jar log4j-1.2.14.jar
cxf-rt-bindings-soap-2.0.3-incubator.jar logkit-1.0.1.jar
cxf-rt-bindings-xml-2.0.3-incubator.jar neethi-2.0.2.jar
cxf-rt-core-2.0.3-incubator.jar saaj-api-1.3.jar
cxf-rt-databinding-aegis-2.0.3-incubator.jar saaj-impl-1.3.jar
cxf-rt-databinding-jaxb-2.0.3-incubator.jar servlet-api-2.3.jar
cxf-rt-frontend-jaxws-2.0.3-incubator.jar servlet-api-2.5-6.1.5.jar
cxf-rt-frontend-simple-2.0.3-incubator.jar slf4j-api-1.3.1.jar
cxf-rt-management-2.0.3-incubator.jar slf4j-jdk14-1.3.1.jar
cxf-rt-transports-http-2.0.3-incubator.jar spring-beans-2.0.7.jar
cxf-rt-transports-http-jetty-2.0.3-incubator.jar spring-context-2.0.7.jar
cxf-rt-transports-jms-2.0.3-incubator.jar spring-core-2.0.7.jar
cxf-rt-transports-local-2.0.3-incubator.jar spring-web-2.0.7.jar
cxf-tools-common-2.0.3-incubator.jar stax-api-1.0.1.jar
geronimo-activation_1.1_spec-1.0-M1.jar stax-utils-20060502.jar
geronimo-annotation_1.0_spec-1.1.jar velocity-1.4.jar
geronimo-javamail_1.4_spec-1.0-M1.jar velocity-dep-1.4.jar
geronimo-jms_1.1_spec-1.1.jar wsdl4j-1.6.1.jar
geronimo-servlet_2.5_spec-1.1-M1.jar wstx-asl-3.2.1.jar
geronimo-ws-metadata_2.0_spec-1.1.1.jar xml-apis-1.3.02.jar
jaxb-api-2.0.jar xml-resolver-1.2.jar

Multi-valued Reversible enum in Java

2007-04-16T14:46:00.000-04:00

Sometime back I proposed a reversible enum pattern in my post. One thing missing from that implementation was the ability to successfully lookup the enum constants in cases where enum constants can have multiple values. To accomplish this, I utilized another feature introduced in Java 5, namely varargs or variable argument support. This way while building the key for the map, we utilize all the values for a constant and use the varargs in the reverse() method of the enum.

Let's look at the interface MultiValueReversibleEnum that denotes an enum as reversible and that an enum should implement.


/**
 * <p>
 * This interface defines the method that the {@link Enum} implementations
 * should implement if they want to have the reversible lookup functionality and
 * define multiple values for each enum constant. i.e. allow the lookup using
 * the codes for the {@link Enum} constants.
 * </p>
 * @param <E>
 *          The value of Enum constant
 * @param <V>
 *          The Enum constant to return from lookup
 *          </p>
 * @author Atif Khan
 * @since Mar 26, 2007
 */
public interface MultiValueReversibleEnum<E, V>
{
  /**
   * <p>
   * Return the values/codes of the enum constant. It should return the
   * values/codes in the same order as defined in the enum.
   * </p>
   * @return value
   */
  public E[] getAllCodes();

  /**
   * <p>
   * Get the {@link Enum} constant by looking up the code in the reverse enum
   * map.
   * </p>
   * @param code
   * @return V - The enum constant
   */
  public V reverse( E ... code );

}

The things to notice in this interface are:

getAllCode() method - It returns an array of all the possible values for an enum constant

reverse( E ... code ) method - You can see the usage of varargs here. You basically give all the possible values for the enum constant you want to lookup in the right order

Next we need to look at the map MultiValueReverseEnumMap that will store the enum constants and their value mappings.


import java.util.HashMap;
import java.util.Map;

/**
 * <p>
 * A utility class that provides a reverse map of the {@link Enum} that is keyed
 * by the values of the {@link Enum} constant. <br/> This map implementation
 * should be used with the enums implementing the
 * {@link MultiValueReversibleEnum} interface.
 * </p>
 * @author Atif Khan
 * @param <K>
 *          The class type of the values of the enum constant
 * @param <V>
 *          The Enum for which the map is being created
 * @since Mar 26, 2007
 */
public class MultiValueReverseEnumMap<K, V extends MultiValueReversibleEnum<K, V>>
{
  private final Map<String, V> mReverseMap = new HashMap<String, V>();

  /**
   * <p>
   * Create a new instance of ReverseEnumMap.
   * </p>
   * @param valueType
   */
  public MultiValueReverseEnumMap( final Class<V> valueType )
  {
    for( final V v : valueType.getEnumConstants() ) {
      mReverseMap.put( buildKey( v.getAllCodes() ), v );
    }
  }

  /**
   * <p>
   * Perform the reverse lookup for the given enum values and return the enum
   * constant.
   * </p>
   * @param enumValues
   * @return enum constant
   */
  public V get( final K ... enumValues )
  {
    return mReverseMap.get( buildKey( enumValues ) );
  }

  /**
   * <p>
   * Build the key for the entry in the map using the array of values supplied.
   * </p>
   * @param values
   * @return key for the entry
   */
  private String buildKey( final K[] values )
  {
    final StringBuilder valueBuff = new StringBuilder( values.length * 5 );
    for( final K value : values ) {
      valueBuff.append( value.hashCode() );
    }

    return valueBuff.toString();
  }
}

As you can see, the getAllCodes() defined in the interface is used to build the key for the map. Also, the get( final K ... enumValues ) method that looks up the value in map uses varargs.

Now it's time to glue everything together and see how to use the interface and map to build a multi-valued reversible enum. We will write a test class MultiValuedEnumTest.


import com.ihg.dec.framework.commons.utils.enums.MultiValueReverseEnumMap;
import com.ihg.dec.framework.commons.utils.enums.MultiValueReversibleEnum;

/**
 * <p>
 * A test class for multi-values enum that implements the
 * <code>MultiValueReversibleEnum</code> interface and uses the
 * <code>MultiValueReverseEnumMap</code>.
 * </p>
 * @author Atif Khan
 * @since Apr 16, 2007
 */
public class MultiValuedEnumTest
{
  enum TestEnum
    implements MultiValueReversibleEnum<Integer, TestEnum>
  {

    ONE(1, 11),
    TWO(2, 22);

    private int mCode1;
    private int mCode2;

    private static final MultiValueReverseEnumMap<Integer, TestEnum> mMap = new MultiValueReverseEnumMap<Integer, TestEnum>(
      TestEnum.class );

    /**
     * Create a new instance of TestEnum. <p/>
     * @param code1
     * @param code2
     */
    private TestEnum( final int code1, final int code2 )
    {
      mCode1 = code1;
      mCode2 = code2;
    }

    /**
     * Get the value of <code>code1</code>. <p/>
     * @return Returns the code1.
     */
    public int getCode1()
    {
      return mCode1;
    }

    /**
     * Get the value of <code>code2</code>. <p/>
     * @return Returns the code2.
     */
    public int getCode2()
    {
      return mCode2;
    }

    /**
     * Get an instance of TestEnum
     * @return TestEnum constant
     */
    public static TestEnum getInstance()
    {
      return TestEnum.ONE;
    }

    /**
     * @see com.ihg.dec.framework.commons.utils.enums.MultiValueReversibleEnum#getAllCodes()
     */
    public Integer[] getAllCodes()
    {
      return new Integer[] {
        getCode1(), getCode2()
      };
    }

    /**
     * @see com.ihg.dec.framework.commons.utils.enums.MultiValueReversibleEnum#reverse(E[])
     */
    public TestEnum reverse( final Integer ... code )
    {
      return mMap.get( code );
    }
  }

  /**
   * <p>
   * The main method to execute this class.
   * </p>
   * @param args
   */
  public static void main( final String[] args )
  {
    System.out.println("Reverse for [1, 11]: " + TestMultiValueEnum.getInstance().reverse( 1, 11 ) );
    System.out.println("Reverse for [2, 22]: " +  TestMultiValueEnum.getInstance().reverse( 2, 22 ) );
  }

}

If you run this class, you should see following getting printed:

Reverse for [1, 11]: ONE
Reverse for [2, 22]: TWO

It's all very simple and straightforward. If you have any suggestions or feedback to improve this, please leave me a comment.

Impression of RIFE Web Framework

2007-04-10T11:05:00.000-04:00

I have been spending time on and off looking at various web frameworks available for a little more than a year. A lot of this has to do with keeping track of what's going on in the web framework arena and keep in sync with the technologies. Another focus of mine is to see how the new (at least for me) frameworks affect the productivity of a developer.

I first looked at RIFE last year and I have been very impressed by the concepts.The developers of RIFE, Geert Bevin and others have been very helpful when I had some questions. I was even able to get answers on the IRC channel for RIFE. It was not until recently that I tried to write an application using RIFE that I really got a feel of it.

Here are some of the good and bad that I encountered:

Pros

A complete framework. It includes basic web framework, ORM, Content Management, Validations, Templates etc.

Good support from developers

A nice quick start application to get you running quickly

Good support for constraints for adding validations

Continuations - ability to pause, rewind, jump through transaction steps

Cons

Templates are really weird to work with. The syntax for the templates really did me. It is not really designer friendly like Tapestry or Wicket

The concept of flowlink and datalink is just too verbose and not clear

Using annotation didn't do me any good as well for defining the flow and data links. There isn't enough documentation for annotations

The only way for form validations I could find was to define the a MetaData class equivalent to the domain object representing the form and define the validations in there. This just seems like way too much of work for simple validations.

I could not figure out how to customize the error messages for form validations

In the end, I feel that it's the lack of documentation that prevented me from really exploring it. I know Geert is a very sharp guy and if he ever gets to read my blog, I welcome his comments. I think the learning curve is too much for RIFE and lack of documentation adds to it and I am not sure if the return is proportional to the effort compared to other frameworks.

A simple file based Ruby Database - KirbyBase

2007-03-27T12:50:00.000-04:00

Have you ever been in a situation where you wanted to write a simple application for internal use that should be portable and completely self contained (including the database)? I am pretty sure you have. I had to do this recently for one of the simple reporting applications and I didn't really want to create a dependency on external database like MySQL or PostgreSQL. This application needed only 4 tables and the data in these table is never going to be large enough to warrant an extensive database system. I thought about putting the data in flat files and write the code to access it. But, then I found this really neat gem called KirbyBase that does exactly the same and little more.

KirbyBase has some neat features that mirror the traditional RDBMS while still sticking to it's simple roots:

Pure Ruby code

Data is kept in simple delimited files, allowing the modification in any text editor

It's not an in-memory DB. The data is actually stored on the disk

Allows various data types like String, Integer, Float, Boolean, Time, Date, DateTime, Memo, Blob, and YAML

Allows creating indexes on fields

Query results can be sorted

Allows to define one-many links between tables similar to joins in RDBMS

The columns can be defined with a formula, so the value will be calculated during insertion

Automatic lookup fields can be defined to lookup the related values from another table

To give a simple example on how all this works, let's consider a scenario of Department and Employees. The simple requirements can be laid out as each employee has personal information and belongs to a department. Also, each department has a name and identifier and can contain multiple employees. Following is how the code going to look using KirbyBase. Please keep in mind that I have tried to write a reusable DAO, hence the code may look a little verbose. You can very well short circuit the whole thing and write very concise code.


#!/usr/bin/ruby -w

require 'rubygems'
require 'kirbybase'

class DAO
  attr_accessor(:employee_tbl, :department_tbl)

  #Initialize the KirbyBase engine
  def initialize
    db = KirbyBase.new(:local, nil, nil, '.')

    #Get/Create the Department table
    begin
      self.department_tbl = db.get_table(:department)
    rescue
      self.department_tbl = db.create_table(:department, :dept_name, {:DataType=>:String, :Key=>true, :Index=>1}, :employee, {:DataType=>:ResultSet, :Link_many=>[:recno, :employee, :dept_id]}) do |t|
        t.record_class = Department
      end
    end

    #Get/Create the Employee table
    begin
      self.employee_tbl = db.get_table(:employee)
    rescue
      self.employee_tbl = db.create_table(:employee, :dept_id, {:DataType=>:Integer, :Key=>true, :Index=>1}, :name, {:DataType=>:String, :Key=>true, :Index=>1}) do |t|
        t.record_class = Employee
      end
    end
  end

  #Get the department by name or if it does not exist, insert it 
  def get_department(name)
    dept = self.department_tbl.select_by_dept_name_index { |r| r.dept_name == name  }.first
    unless dept
      dept = Department.new do |x|
        x.dept_name = name
      end
      self.department_tbl.insert(dept)
      dept = self.department_tbl.select_by_dept_name_index { |r| r.dept_name == name  }.first
    end
    return dept
  end

  #Insert a new employee in table
  def insert_employee(dept, employee)
    employee_rs = self.employee_tbl.select_by_dept_id_name_index { |r| r.dept_id == dept.recno and r.name == employee.name }.first

    if employee_rs
     self.employee_tbl.update(employee) { |r| r.dept_id == dept.recno and r.name == employee.name }
    else
      employee_obj = Employee.new do |x|
        x.dept_id = dept.recno
        x.name = employee.name
      end
      self.employee_tbl.insert(employee_obj)
    end
    
  end

  #Get all employees for a department
  def get_all_employees(dept)
    employee_rs = self.employee_tbl.select_by_dept_id_name_index { |r| r.dept_id == dept.recno }.sort(:name)
  end
  
end

# The Department class
class Department
  attr_accessor(:recno, :dept_name, :employee)

  def Department.kb_create(recno, dept_name, employee)
    Department.new do |x|
      x.recno = recno
      x.dept_name = dept_name
      x.employee = employee
    end
  end

  def initialize(&block)
    instance_eval(&block)
  end
end

# The Employee class
class Employee
  attr_accessor(:recno, :dept_id, :name)

  def Employee.kb_create(recno, dept_id, name)
    Employee.new do |x|
      x.recno = recno
      x.dept_id = dept_id
      x.name = name
    end
  end

  def initialize(&block)
    instance_eval(&block)
  end
end

#Test everything now
dao = DAO.new
dept = dao.get_department("IT")

emp1 = Employee.new { |x| 
  x.name = "John"
}
dao.insert_employee(dept, emp1)

emp2 = Employee.new { |x|
  x.name = "Doe"
}
dao.insert_employee(dept, emp2)

#Get all empoyees in IT department and print
#Let's use the get_all_employees function first
puts "Employee in #{dept.dept_name} department"
dao.get_all_employees(dept).each { |x|
  puts x.name
}

#Alternatively we could use the dept.employee to get all employees
#Refresh the dept object
dept = dao.get_department("IT")
puts "Employee in #{dept.dept_name} department"
dept.employee.each { |x|
  puts x.name
}

The output after execution will look like this:


Employee in IT department
Doe
John

Employee in IT department
John
Doe

This should also generate 2 files in your current directory, department.tbl and employee.tbl. Let's look at content of these files now.

department.tbl


000001|000000|Department|recno:Integer|dept_name:String:Key->true:Index->1|employee:ResultSet:Link_many->recno=employee.dept_id
1|IT|kb_nil

employee.tbl


000002|000000|Employee|recno:Integer|dept_id:Integer:Key->true:Index->1|name:String:Key->true:Index->1
1|1|John
2|1|Doe

That's all there to it. It is very powerful and easy to work with library.

Rich Web UI, Flash and DHTML - Bridge the gap

2007-01-15T15:37:00.000-05:00

As the Web 2.0 grows in popularity, so does the urge for a lot of organizations to revamp their legacy applications and make them web based. Their are obvious benefits to this as the application becomes more accessible and requires less effort to deploy and maintain as there is single point of deployment and maintenance, the application server. What gets lost in all this excitement is the functionality that may have been available in the existing applications with rich user interfaces can not be easily replicated in the web application replicating it. By using the readily available javascript libraries and AJAX techniques some of this pain can be alleviated. It's not necessary that web applications may always lose the usability of functionality of the original application. In fact they can actually simplify some of the transactions if the user experience is considered from beginning during the rewrite process.

I have been playing with OpenLaszlo recently and it seems like a viable alternative for replacing the standalone applications with rich user interface. The most important feature of OpenLaszlo is the ability to write the user interface in XML based LZX language and export it to either Flash (.sfw) bytecode or DHTML. This functionality is only available with the upcoming Project Legals release of OpenLaszlo, which is already in beta.

It has a rich set of components and event model that can all be used and programmed to using the LZX language. You can also write your own components using the LZX markup. The important thing to keep in mind is that OpenLaszlo is strictly a UI technology. You still need to get your data to display from the backend whether it being database of another middleware. This is where OpenLaszo excels. At the core it can interact with a back end system using the RPC. Various RPC options include:

Java RPC
SOAP

XML RPC

XMLHttpRequest for Ajax

So, you can pretty much have you back end written in Java, PHP, Ruby or whatever you like as long as it supports either RPC, SOAP or XMLHttpRequest. If you are wondering about what do you need on your server to run OpenLaszlo, it is basically a Java Servlet based web application. So, you do need the Java servlet container on your server to run OpenLaszlo. That shouldn't be an issue at all if you already use Java.

If you do use Java on the server side and you have been trying to decide between various web application frameworks available and there are a ton of them :), OpenLaszlo can make your life a little simpler as you don't have to worry about the components or the component state management (JSF, Wicket, Tapestry etc). All you need is a solid framework that can preferably produce XML output and serve some data (Struts, WebWork, Spring MVC, RIFE) or any other similar framework and leave the UI aspect to OpenLaszlo. OpenLaszlo may not be suitable in all the cases, but it is worth a look if you want a web application with the look and feel and usability of a desktop application.

When will Sun's JDK start following code conventions?

2006-12-12T11:52:00.000-05:00

A lot of Java applications run on Sun's JDK due to various reasons. In fact till recently Sun had a very restrictive license policy for Java. So, effectively Sun's JDK has been a de facto standard. That's the reason Sun's JDK code is supposed and expected to be of high quality and following at least the coding conventions recommended by Sun in a 1999 article that is widely used.

If you look under the hood of JDK, you will find a completely different picture. Here is an example from the Java 6 source code of StringBuilder class. (I have noticed similar stuff in 1.4 and 1.5 releases.)


    // Appends the specified string builder to this sequence.
    private StringBuilder append(StringBuilder sb) {
  if (sb == null)
            return append("null");
  int len = sb.length();
  int newcount = count + len;
  if (newcount > value.length)
      expandCapacity(newcount);
  sb.getChars(0, len, value, count);
  count = newcount;
        return this;
    }

How many non-conformance instances can you find? Here is what I notice:

Indentation - not sure if it was edited in notepad (even vi does indentation) or a result of source control merge?.

If clause doesn't use brackets- Here is an excerpt from Sun's Java coding conventions.


The if-else class of statements should have the following form:

    if (condition) {
        statements;
    }

    if (condition) {
        statements;
    } else {
        statements;
    }

    if (condition) {
        statements;
    } else if (condition) {
        statements;
    } else {
        statements;
    }
     

Note: if statements always use braces {}. Avoid the following error-prone form:

    if (condition) //AVOID! THIS OMITS THE BRACES {}!
        statement;

Need I say more?

Creating "null" string instance- Why can't it be represented by a static final constant and reused? All the string literals are stored in JVM in a String pool, even the ones defined as constants. Isn't it more optimized if you have a direct reference to it rather than JVM doing a lookup in the pool every time you call the method?
Note: After looking at the bytecode generated by the compiler, it looks like a direct reference is pushed on the stack for the string literal. So, it effectively doesn't matter if you use a literal or a constant. Still, if you are using a string literal over and over again, it may be a better idea to create a constant. This way if you need to change the string literal, there is only one place where you need to make change. So, you protect yourself against future changes. Thanks to Messi for pointing this out in the comments :).

Variables can be made final-The method parameter sb and local variables len and newcount can all be declared final for optimization. This article has good explanation for it.
Note: Again after analyzing the bytecode it seems like compiler really doesn't care about the final declaration for the local variables. The method parameter are a different case as by declaring them final you make sure that they are not modified by mistake. Also, the local variables can be declared as final as a coding practice to mark them as immutable even though it doesn't affect the byte code. But it makes it clear for a person looking at your code that the variable can not be modified. Thanks to Messi and Kevin Riff for pointing this out in the comments :)

This is just an example. There are instances like this all over the JDK code base. I want to make it clear that I am not commenting on the performance aspect of JDK, just the code conventions and formatting (for the obvious reasons that the code should be properly formatted). Now, since Sun has released the JDK source code under GPL license, do we expect to see things like this continue? Do you think people will take more responsibility and clean up the JDK code? I hope so. I also hope that Sun does not blacklist me after this post :)

Java wish: A Reversible Enum

2006-12-04T11:24:00.000-05:00

One of the biggest feature added with JDK 1.5 is enum support. At last you can use a language construct to define constants in the system rather than using the static final to define the constants. The obvious benefits of enums are type safety and type checking.

Also enums let you define meaningful values for the constants. e.g.


public enum MathEnum {
  PI(3.14159),
  LOG_E(2.71828);

  private double mValue;

  MathEnum(final double value) {
    mValue = value;
  }

  public final Double getValue() {
    return mValue;
  }
}

As you can see in the above example, you can use the enum constant PI across your code, but if you wanted to get the value of PI, you can do that by using PI.getValue().

This is where things get a little fuzzy. What if you have a double value representing either PI or LOG_E and you want to find out which constant in MathEnum represents that value? This is the reverse lookup of enum. The Java implementation of enum does not allow reverse lookup by value. It is a very useful feature if you are working with an existing code base and an external system returns values for the constants that need to be translated into Java Enums.

Here is how this problem can be solved by using the Reversible Enum Pattern. First we need to create a ReversibleEnum interface that will mark the Enums as reversible and define the required method.


/**
 * <p>
 * This interface defines the method that the {@link Enum} implementations
 * should implement if they want to have the reversible lookup functionality.
 * i.e. allow the lookup using the code for the {@link Enum} constants.
 * </p>
 * @author Atif Khan
 * @param < E >
 *          The value of Enum constant
 * @param < V >
 *          The Enum constant to return from lookup
 */
public interface ReversibleEnum< E, V >
{
  /**
   * <p>
   * Return the value/code of the enum constant.
   * </p>
   * @return value
   */
  public E getValue();

  /**
   * <p>
   * Get the {@link Enum} constant by looking up the code in the reverse enum
   * map.
   * </p>
   * @param  E - code
   * @return V - The enum constant
   */
  public V reverse( E code );
}

Next, we need to define a Map that will be used to store the enum constant values and for reverse lookup.


import java.util.HashMap;
import java.util.Map;

/**
 * <p>
 * A utility class that provides a reverse map of the {@link Enum} that is keyed
 * by the value of the {@link Enum} constant.
 * </p>
 * @author Atif Khan
 * @param < K >
 *          The class type of the value of the enum constant
 * @param < V >
 *          The Enum for which the map is being created
 */
public class ReverseEnumMap< K, V extends ReversibleEnum< K, V >>
{
  private final Map< K, V > mReverseMap = new HashMap< K, V >();

  /**
   * <p>
   * Create a new instance of ReverseEnumMap.
   * </p>
   * @param valueType
   */
  public ReverseEnumMap( final Class< V > valueType )
  {
    for( final V v : valueType.getEnumConstants() ) {
      mReverseMap.put( v.getValue(), v );
    }
  }

  /**
   * <p>
   * Perform the reverse lookup for the given enum value and return the enum
   * constant.
   * </p>
   * @param enumValue
   * @return enum constant
   */
  public V get( final K enumValue )
  {
    return mReverseMap.get( enumValue );
  }
}

You will notice that in both the ReversibleEnum interface and the ReverseEnumMap class the Generics template is used. This is done to customize these based on the type of the enum that will use them and the type of the value of enum constants. If this sounds confusing, it will become more clear after we see the modified version of the MathEnum class from earlier.


public enum MathEnum implements ReversibleEnum< Double, MathEnum > 
{
  PI(3.14159),
  LOG_E(2.71828);

  private double mValue;
  private static final ReverseEnumMap< Double, MathEnum > mReverseMap = new ReverseEnumMap< Double, MathEnum >(
    MathEnum.class );

  MathEnum(final double value) 
  {
    mValue = value;
  }

  public final Double getValue() 
  {
    return mValue;
  }

  public MathEnum reverse( final Double value )
  {
    return mReverseMap.get( value );
  }

  public static MathEnum getInstance()
  {
    return values()[0];
  }

}

The changes you will notice here are:

MathEnum implements the ReversibleEnum interface.

New variable for ReversibleEnumMap

New method reverse(final Double value) to do the reverse lookup. This is from the ReversibleEnum interface.

New static method getInstance() that just returns the first constant of the enum. This is kind of a hack to get a reference to an instant of the enum, so that the reverse(..) method could be called on it.

Now to do a reverse lookup on the MathEnum, all you need to do is:


MathEnum.getInstance().reverse(3.14159); // Will return PI

Lets recap all the steps needed to be done to create a reversible enum:

Define an interface ReversibleEnum. -- One time job.

Define a new class ReverseEnumMap. -- One time job.

Implement the ReversibleEnum interface and define a member variable of type ReverseEnumMap in the enum that you want to be reversible. If you do not need the reverse functionality, you don't need to do any of this.

So, effectively once you have the interface and map class created, it's minimal effort to create a reversible enum. I wish this was a built-in functionality in the JDK enum implementation.

A Simple LRU Cache in 5 lines

2006-11-27T13:01:00.000-05:00

The applications usually need to cache information in memory. The most often used classes to do this in Java are HashMap and Hashtable. If you need to do any sophisticated caching, then you can use JBoss Cache, OSCache or EHCache. Even if you use an external caching system, you may still want to cache some information locally within an object just to have fast access. The problem with this approach is that, if you are not careful and do not control the size of this in-memory cache, then it may grow too big and affect the performance of your application.

A very simple solution to this problem is to set a maximum size for your in-memory cache and most preferably make it LRU (Least Recently Used). This way you will have a predictable memory utilization and only the items used recently will be kept in the cache.

Starting with JDK 1.4, a new (and very rarely used) collection class was added called LinkedHashMap. There are couple of benefits of using a LinkedHashMap:

It is possible to preserve the order of items in the map. So, the order of iteration through the items is same as the order of insertion. A special constructor is provided for this purpose. This is very useful when you already have a sorted collection of data and you want to do some processing on it and return it as a Map. Using a TreeMap (the only other map that allows iteration in a given order) is too expensive for this scenario.

It exposes a method removeEldestEntry(Map.Entry) that may be overridden to impose a policy for removing stale mappings automatically when new mappings are added to the map. This is what we are going to use to create a LRU cache.

Check out the following snippet for an example of simple LRU cache.


import java.util.*;

public class SimpleLRU {

  private static final int MAX_ENTRIES = 50;

  private Map mCache = new LinkedHashMap(MAX_ENTRIES, .75F, true) {
    protected boolean removeEldestEntry(Map.Entry eldest) {
      return size() > MAX_ENTRIES;
    }
  };

  public SimpleLRU() {
    for(int i = 0; i < 100; i++) {
      String numberStr = String.valueOf(i);
      mCache.put(numberStr, numberStr);

      System.out.print("\rSize = " + mCache.size() + "\tCurrent value = " + i + "\tLast Value in cache = " + mCache.get(numberStr));
      try {
        Thread.sleep(10);
      } catch(InterruptedException ex) {
      }
    }

    System.out.println("");
  }

  public static void main(String[] args) {
    new SimpleLRU();
  }
}

This code creates a simple LRU cache with maximum 50 entries. The magic happens during the creation of the LinkedHashMap where a boolean flag for access order is set to true and the method removeEldestEntry is overridden. Now, if you run the program, you can see that the cache size is fixed to 50 entries and the least recently used entries are removed from the map. It is possible to create a pruning thread to prune the map so you don't always necessarily maintain the maximum number of entries.

PMD bug with @SuppressWarnings annotation

2006-11-14T11:56:00.000-05:00

PMD is an open source static analysis tool for the Java source code. It has a pretty good set of standard rules and you can add new rules by using XPath or Java code against the AST (Abstract Syntax Tree) it generates from the source code. The code analysis tools help you to keep your code clean and simple and avoid common pitfalls.

I recently found a bug while trying to analyze the code in the JDK 1.5 mode using PMD 3.8 version. The PMD seems to be ignoring all the violations for the class/method if you have a @SuppressWarnings annotation in it. According to the PMD documentation, only if you have @SuppressWarnings("") in your code, it's supposed to ignore the violations for that class/method. But, the source code for PMD does not implement this logic. It just checks for the presence of @SuppressWarnings annotation and not any values passed to it. The end result is that all the violations are ignored. This can be very annoying as you may miss a significant number of violations.

To fix this issue, I made a couple of changes to the PMD source code. These are listed below with explanations:

net.sourceforge.pmd.ast.ASTAnnotation - This is the class where the check for @SuppressWarnings is implemented. I made changes to the suppresses(Rule rule) method of this class to check if any values are passed to this annotation. If any values except "" are passed (e.g. @SuppressWarnings("unchecked")), then all the PMD violations are written to the report. Otherwise if "" is passed, all the PMD violations are suppressed.


    public boolean suppresses(Rule rule) {
        /*Check for "suppress all warnings" case
           @SuppressWarnings("")
           TypeDeclaration
           Annotation
           NormalAnnotation
           Name:SuppressWarnings
        */

        if (!(jjtGetChild(0) instanceof ASTSingleMemberAnnotation) && !(jjtGetChild(0) instanceof ASTNormalAnnotation)) {
          return false;
        }

        final SimpleJavaNode n = (SimpleJavaNode) jjtGetChild(0);
        if(!(n.jjtGetChild(0) instanceof ASTName) || !((ASTName) n.jjtGetChild(0)).getImage().equals("SuppressWarnings")) {
          return false;
        }

        final List suppressionQualifierNodeList = n.findChildrenOfType( ASTLiteral.class );
        final Iterator suppressionQualifierNodeIt = suppressionQualifierNodeList.iterator();
        while(suppressionQualifierNodeIt.hasNext()) {
          final ASTLiteral literalNode = (ASTLiteral)suppressionQualifierNodeIt.next();
          if(literalNode == null) {
            continue;
          }
          final String literalImage = literalNode.getImage();
          if(literalImage != null && literalImage.trim().equals( "\"\"" )) {
            return true;
          }
        }

        return false;
    }

net.sourceforge.pmd.renderers.XMLRenderer - You need to change this only if you generate your PMD reports in the XML format. The changes I made here are to improve the information presented for suppressed violations tag (<suppressedviolation>). So, if you decide to use the @SuppressWarnings("") annotation, at the end of reports their will be a section for suppressed violations. Another change I made is to enclose all the <suppressedviolation> tags inside a <file> tag for each file just like regular violations.

  public String render( Report report )
  {

    StringBuffer buf = new StringBuffer(
      "< ?xml version=\"1.0\" encoding=\"UTF-8\"?>" + PMD.EOL + createVersionAttr()
        + createTimestampAttr() + createTimeElapsedAttr( report ) + ">" + PMD.EOL );
    String filename = null;

    // rule violations
    for( Iterator i = report.iterator(); i.hasNext(); ) {
      IRuleViolation rv = (IRuleViolation)i.next();
      if ( !rv.getFilename().equals( filename ) ) { // New File
        if ( filename != null ) {// Not first file ?
          buf.append( "" + PMD.EOL );
        }
        filename = rv.getFilename();
        buf.append( "<file name=\"" );
        StringUtil.appendXmlEscaped( buf, filename );
        buf.append( "\">" ).append( PMD.EOL );
      }

      buf.append( "<violation line=\"" ).append( rv.getBeginLine() ).append( "\"" );
      buf.append( " rule=\"" );
      StringUtil.appendXmlEscaped( buf, rv.getRule().getName() );
      buf.append( "\"" );
      buf.append( " ruleset=\"" );
      StringUtil.appendXmlEscaped( buf, rv.getRule().getRuleSetName() );
      buf.append( "\"" );
      maybeAdd( "package", rv.getPackageName(), buf );
      maybeAdd( "class", rv.getClassName(), buf );
      maybeAdd( "method", rv.getMethodName(), buf );
      maybeAdd( "externalInfoUrl", rv.getRule().getExternalInfoUrl(), buf );
      buf.append( " priority=\"" );
      buf.append( rv.getRule().getPriority() );
      buf.append( "\">" );
      buf.append( PMD.EOL );
      StringUtil.appendXmlEscaped( buf, rv.getDescription() );

      buf.append( PMD.EOL );
      buf.append( "</violation>" );
      buf.append( PMD.EOL );
    }
    if ( filename != null ) { // Not first file ?
      buf.append( "</file>" + PMD.EOL );
    }

    // errors
    for( Iterator i = report.errors(); i.hasNext(); ) {
      Report.ProcessingError pe = (Report.ProcessingError)i.next();
      buf.append( "<error " ).append( "filename=\"" );
      StringUtil.appendXmlEscaped( buf, pe.getFile() );
      buf.append( "\" msg=\"" );
      StringUtil.appendXmlEscaped( buf, pe.getMsg() );
      buf.append( "\"/>" ).append( PMD.EOL );
    }

    // suppressed violations
    if ( showSuppressedViolations ) {
      int count = 0;
      for( Iterator i = report.getSuppressedRuleViolations().iterator(); i.hasNext(); ) {
        Report.SuppressedViolation suppressed = (Report.SuppressedViolation)i.next();

        if ( !suppressed.getRuleViolation().getFilename().equals( filename ) || count == 0 ) { // New
          
          // File
          if ( filename != null && count > 0 ) {// Not first file ?
            buf.append( "" + PMD.EOL );
          }
          filename = suppressed.getRuleViolation().getFilename();
          buf.append( "<file name=\"" );
          StringUtil.appendXmlEscaped( buf, filename );
          buf.append( "\">" ).append( PMD.EOL );
        }
        buf.append( "<suppressedviolation line=\"" ).append(
          suppressed.getRuleViolation().getBeginLine() ).append( "\"" );
        buf.append( " rule=\"" );
        StringUtil.appendXmlEscaped( buf, suppressed.getRuleViolation()
          .getRule()
          .getName() );
        buf.append( "\"" );
        buf.append( " ruleset=\"" );
        StringUtil.appendXmlEscaped( buf, suppressed.getRuleViolation()
          .getRule()
          .getRuleSetName() );
        buf.append( "\" suppressiontype=\"" );
        StringUtil.appendXmlEscaped( buf, suppressed.suppressedByNOPMD() ? "nopmd"
          : "annotation" );
        buf.append("\"");
        maybeAdd( "package", suppressed.getRuleViolation().getPackageName(), buf );
        maybeAdd( "class", suppressed.getRuleViolation().getClassName(), buf );
        maybeAdd( "method", suppressed.getRuleViolation().getMethodName(), buf );
        maybeAdd( "externalInfoUrl", suppressed.getRuleViolation()
          .getRule()
          .getExternalInfoUrl(), buf );
        buf.append( " priority=\"" );
        buf.append( suppressed.getRuleViolation().getRule().getPriority() );
        buf.append( "\" usermsg=\"" );
        StringUtil.appendXmlEscaped( buf, suppressed.getUserMessage() );
        buf.append( "\">" );
        buf.append( PMD.EOL );
        StringUtil.appendXmlEscaped( buf, suppressed.getRuleViolation()
          .getDescription() );

        buf.append( PMD.EOL );
        buf.append( "</suppressedviolation>" );
        buf.append( PMD.EOL );
        
        count++;
      }
      final String fileEndStr = "</file>" +  PMD.EOL;
      if(!buf.substring( buf.length() - fileEndStr.length() ).equalsIgnoreCase( fileEndStr)) {
        buf.append( fileEndStr );
      }
    }

    buf.append( "" );
    return buf.toString();
  }

net.sourceforge.pmd.util.StringUtil - This was throwing NullPointerException for the suppressed violations while generating the report. I just added a null check here.

  private static void appendXmlEscaped(StringBuffer buf, String src, boolean supportUTF8) {
    char c;

    if(src == null) {
      return;
    }
    .......
    .......

You can just replace the whole methods for ASTAnnotation and XMLRenderer classes and add the code snippet for StringUtil class. Once you do that you are ready to do the build. Run following in the bin directory of pmd-3.8 or the directory where you extracted the source code:

ant dist

That should create the pmd-3.8.jar in the lib directory. Now, you can use this jar whether you use the command line, ant or eclipse plugin to run PMD. If you have any questions, please leave me a comment.

Charts in Ruby - Using Gruff

2006-11-09T08:44:00.000-05:00

It is very common requirement for any reporting application to be able to draw charts based on some historical and statistical data. The languages with big user community like Java have various libraries available for creating charts. But when it comes to Ruby, there are not as many or as sophisticated choices. I was looking for a library in Ruby to do this sometime back and I found Gruff. It's a very simple and efficient library.

To install Gruff, all you need to do is:

gem install gruff

You also need to have the RMagick installed that needs the ImageMagick to be installed. You can install ImageMagick using the package manager of your Linux distribution or download it directly from ImageMagick website and install. The RMagick installation can be done by either using gem or using the native OS package manager. On my Mandriva Linux box, the gem installation kept on failing during compilation. So, I just installed it using urpmi and it worked.
I wrote a small module in Ruby to draw the line charts. This module can be included in the scripts where you need to draw the charts. This module is called charts.rb. Here is the source code for it:

require 'rubygems'
require 'gruff'
require 'RMagick'

module Chart
  def Chart.drawChart(title, dataHash, labelHash, path, scale, colors)
    begin
      g = Gruff::Line.new(700)
      g.title = title
      count = 0
      for dataTitle in dataHash.keys
        if colors && colors[count]
          g.data(dataTitle, dataHash.fetch(dataTitle), colors[count])
        else
          g.data(dataTitle, dataHash.fetch(dataTitle))
        end
        count = count + 1
      end
      g.labels = labelHash
      g.marker_font_size = 16
      g.title_font_size = 20
      if dataHash.size == 1
        g.hide_legend = true
      end
      g.write(path)
      resize(path, scale)
    rescue Exception => e
      puts e
    end
  end

  def Chart.resize(imagePath, scale)
    img = Magick::ImageList.new(imagePath)
    img.resize!(scale)
    img.write(imagePath)
  end

end

The arguments for drawChart function are as follows:

Title of the chart

A Hash of the data (the Caption for data => Array of data)

A Hash of labels for the X axis

Path of the final generated image

The scale of the image from the original chart size of 700px*700px

An array of hex colors if you do not want to use Gruff's default color scheme

Now, here is how you can use the chart module and the drawChart function:


require 'chart.rb'
....
colors = ['#f9181e', '#f95818', '#f6f918', '#1862f9', '#1ef918']
....
Chart.drawChart("Violations with Priorities 1 and 2 only", Hash["Priority1" => violation1Arr, "Priority2" => violation2Arr], timelineGHash, "violation.jpg", 0.7, colors)

That's pretty much all the code. In the end you should have a chart generated like following:

Path to Ruby Scripts

2006-10-31T11:50:00.000-05:00

Ever wondered how to set the path to some Ruby scripts you have written, so you can use them using "require"? There is a very basic solution for this problem. You need to define a system variable called RUBYLIB and point it to the directory containing your Ruby scripts. Then in your script where you want to use the library or script you created, you can simply do a "require" with the name of the script.

e.g. Supposed you created a script chart.rb in /home/foo/ruby/mylib direcory. Now, you want to use this in the app.rb located in /home/foo/ruby/scripts. Here is how you can make it work in a Linux bash environment. You could very well do this in other environments as well with minimal modifications.
In your ~/.bash_profile

export RUBYLIB=$RUBYLIB:/home/foo/ruby/mylib

and then in the app.rb script:

require 'chart'

That's it.