dhaval

Playing with the Play Framework

2011-02-25T14:12:00.000-08:00

Back to blog after very long time. This post is basically about the new exciting Java web framework Play and a small implementation of app using it: pptViewer a simple PPT file viewer.

After successfully implementing (basically porting) a small application in Play I can say that every Java programmer who wants to taste agile development must use this framework at least once. Its really simple and lighting fast to build (small to medium size) applications. I have selected this framework for few of my upcoming prototype developments.

The demo application is very trivial one. It accepts a Microsoft PPT file and shows the slide contents on pages. Apache POI is used to extract PPT file content and stored in MySql database. The original application is intended to manage multiple format Office files over web and is currently under development using Spring MVC. I choose to rebuild a small part of it using Play to evaluate it for slightly bigger and complex application and it worked really well. The framework documentation is very clear and concise for the beginners to quickly learn and implement stuff. The Play Community is growing day by day and illustrates a lot of new features\implementations of the framework.

Play provides most of the features required by any standard web applications (just like RoR, Django and Grails - actually the search is not over yet)). Standard (Static) MVC model, no upfront compilation (a great boon), front-end scripting and full Java stack are few of them. Play infrastructure can be extended with Modules (plugins) and many useful modules are already available. Play can fit nicely between regular Java web framework like Spring MVC and very dynamic framework like Grails. In the end Play has many similarities to Rails and one can say that like many other modern web frameworks (Grails, Roo) Play Team is also quite inspired from RoR.

After "playing" with GWT, Vaadin, Roo and Grails for a while and with my ongoing implementation I think Play is a very good framework in one's framework wardrobe.

A very good discussion of Play and RoR can be found on this Stackoverflow link.

Although my journey with Play is quite short till now but I quite impressed at the moment (if it doesn't work then something new will come, it has always come and I will start using that :) ).

Keep "play"ing.

(Special credit to Linode which enabled me to host the application from setup to deployment in just couple of hours. I found Linode setup rather easy enough than to convert the application to GAE compatible.)

Important Callers - My first android app into the wild

2010-10-05T11:18:00.000-07:00

Important
Callers

After developing several Android apps just for fun I finally developed the Important Callers app which can be used by many app users. The app is quite simple and helps the mobile user to not miss important calls by selecting the contacts as important one through the this app.

This is the review (very poor on first day) page of AppBrain for my app and if you have AppBrain installed in your mobile you can install the app from the web page itself. I am upgrading the app as I have started receiving errors and comments as well.

Using jQuery with Vaadin

2010-08-17T23:28:00.000-07:00

After spending some time with Vaadin and developing a small application and a usability framework the moment came in which Vaadin application had to be integrated with another existing application. The integration wasn't tough at all due to the nice work done by the Vaadin folks.

However at my place we have separate team for Vaadin core development and jQuery / JavaScript doing the client side hacking. So to make the job easier for both the sides I developed a small Contact Us demo application which creates a Vaadin form and beautifies it with jQuery Effects and Tooltip plugin.

Story Board - a small app built with jQuery and jQuery UI

2010-07-19T23:07:00.000-07:00

After spending much time with Java and other Java technologies working behind the curtains in the dark and smoky rooms I started exploring front-end dominant languages like JavaScript, HTML5 and much talked CSS.

There are many JavaScript libraries and tools available out there but in all I really liked jQuery; it is simple and easy to use and growing at very rapid speed. More and more applications have started using jQuery extensively.

In this small application (I call it StoryBoard) I have used jQuery along with equally power jQuery UI library which gives a lot of functionality and control with much less code.

I use http://jsfiddle.net/ along with NetBeans to create small demo and find it really helpful to develop and test the application rapidly.

Application Url: http://mstoryboard.appspot.com

Twitter API with jQuery

2010-05-10T11:12:00.000-07:00

After spending some time with Twitter REST API and jQuery; I decided to develop a small application to test both of these together. The example uses jQuery Ajax commands to load the given users public timeline through Twitter REST API.

jQuery is awesome and very popular JavaScript library which provides zillions of operations to manipulate client side objects. jQuery Ajax operations make it very easy to call the Twitter REST API and get the data in JSON format. The following line of code will call the Twitter for a user public timeline.

var url = "http://twitter.com/status/user_timeline/"+ $("input#tweepal").val()+".json?callback=?";
$.getJSON( url, function( data ){
// process the reply
});

For simplicity I have taken a textbox to enter the Twitter username with id "tweepal". The Twitter REST url contains a query string parameter "callback" without which Twitter reply will not be available to the Ajax function. Once received the data can be accessed like a normal JavaScript object. The received object is an array of tweets which can be easily traversed with jQuery.each() function.

$.each(data, function(n, tweet){
$("div#tweet_time").val(tweet.created_at);
$("div#tweet_text").val(tweet.text);
});

This completes all the blocks required to interact with Twitter from client side only.

However there are plenty of libraries available for Twitter but its always exiting to make something on your own (specially using Twitter). Well I am struggling on how to post update using OAuth in same example. Will definitely post if get success.

jVark - A small Java/XMPP library to play with Aardvark

2010-04-14T08:42:00.000-07:00

After spending some time with Aardvark, i found the tool really great to get answers pretty fast. Aardvark provides many ways to interact with the service however there are no APIs available as such to interact with the service programmatically. Meanwhile I was trying to make my hands dirty with Google GTalk service and developed a small and silly utility to interact with Aardvark service through GTalk in Java.

The library is very basic and helps the developer to connect to Aardvark and fire some command and see the response from Aardvark. jVark source is available at http://code.google.com/p/jvark

However the library requires significant amount of improvement for extensive use.

Distributed component events

2010-04-09T21:56:00.000-07:00

The application is inspired from the Seam Component Events and uses Spring AOP for event trapping and JGroup for event distribution. The system is divided into two parts Event Generation and Event Consumption. Simple POJOs can be turned into event generator or event consumer.

// Event Generator
@Component("temperature-sensor")
public class TemperatureManager{
    @Out
    private Temperature currentTemperature;

    @RaiseEvent("temperature-updated")
    public void temperatureUpdated(Temperature t){
        this.currentTemperature = t;
    }
}

// Event Consumer
@Component("graph-generator")
public class GraphGenerator{
    @In
    private Temperature currentTemperature;

    @ConsumeEvent("temperature-updated")
    public void updateTemperature(){
        graph.displayTemperature(currentTemperature);
        // refresh graph
    }
}

The above two classes can be part of a single JVM or multiple JVM, with JGroup in place Event Consumer will still consume the events generated by the Event Generator running in different JVM. Spring AOP keeps track of the RaiseEvent annotation and does all the distribution and communication stuff.

Full source code and required libraries with NetBeans project is available at : component-events.rar

A cool Vaadin application on Google App Engine

2010-04-07T13:12:00.000-07:00

Vaadin, as we all know is a rapidly growing GWT based Java Web Framework. The coolest feature of Vaadin is that there is no client/server concept as it is in GWT. The developer can freely code anything "anywhere" and Vaadin will handle all the client/server related stuffs.

One of our existing in-house production application is built using GWT and causing lot of difficulties for developers in terms of understanding the model and designing the proper application. So to retain all the GWT features and offload the additional burdens we (as such I) have decided to move to the Vaadin and redesign the existing application.

To convince the technical and management team and for demonstration purpose I developed a small application in Vaadin and uploaded it to the Google Application Engine (click here) so that others can also get the idea and at the same time I can load test the application and get all the execution details from the App Engine dashboard.

The application contains a simple functionality where in which the user can design her custom entry forms, enter/save form data and finally view the saved data in a table. The application was built in few hours only so it doesn't have "next big ground breaking idea" or the nice GUI but Vaadin provides fairly nice UI which can work for any application to start with.

To speed up the development I extended the basic Form functionality to a Generic Form so that UI Forms can be created not only from Java Beans but from java.util.Map also. The reason to choose this is because some of our applications are purely data centric where in which numbers of UI forms are presented to users; however the fields in every form can very even after application deployment so to reduce the repetitive development effort I have taken the model where in which forms not only can be generated at runtime but can behave line a normal pre-coded form in most of the cases.

There are still many points to resolve before we finally switch over to Vaadin as our web application development framework but with the growing popularity of the framework and new initiative like Vaadin Directory acceptance would not be much difficult.

Vaadin demo application url: http://vaadincoolapp.appspot.com/

gag - Google Annotations Gallery

2010-04-05T22:25:00.000-07:00

gag is a new exciting open source library has been released by Google for Java. Google Annotations Gallery contains handful of annotations to spice up the code. This new library is aiming to express the code in the more realistic way than just plain old non-readable Javadoc comments.

Not only one can leave expressive remarks in the code, but can use these annotations to draw attention to her poetic endeavors. Apart from static documentation some annotations use runtime instrumentation to perform annotated behavior also. The annotations are divided into following different categories:

Disclaimer: Disclaimer annotations allow you to disclose certain relevant facts about your code. If you want to ease your conscience with full transparency, then consider these annotations.

Enforceable: Enforceable Annotations are annotations enforced by dynamic bytecode instrumentation. Use the following annotations, then run your applications with the javaagent:gag-agent.jar option and your annotations get enforced at runtime.

Literary and Literary Verse: Coding is truly an art. These annotations can help you make your code come alive and help the artist within you be recognized. These speak for themselves . . . so to speak. You'll forever be revered for your code style and your code style. Literary Verse is a newly added sub package of Literary.

Remarks: Remarks annotations replaces the conventional Javadoc comments. These annotations helps better expressing the code than usual Javadoc comments.

Team: This is the new category added recently. The annotations express the team behavior and can be used to express events took place during team development.

Follwing is the list of my personal favorite annotations from the gag gallery:

From Desclaimer:
@com.google.gag.annotation.disclaimer.BossMadeMeDoIt("i swear its not my fault")
@com.google.gag.annotation.disclaimer.IAmAwesome("really, this is the coolest code i have ever written")
@com.google.gag.annotation.disclaimer.WrittenWhile("i m lost, i m lost, omg i m lost")
@com.google.gag.annotation.disclaimer.LegacySucks

From Enforceable:
@com.google.gag.annotation.enforceable.AnswerToTheUltimateQuestionOfLifeTheUniverseAndEverything
@com.google.gag.annotation.enforceable.Noop

From Literary:
@com.google.gag.annotation.literary.Metaphor
@com.google.gag.annotation.literary.Oxymoron("truly a fine mess")

From Remarks:
@com.google.gag.annotation.remark.WTF("this is bullshit")
@com.google.gag.annotation.remark.LOL("this is legend...... wait for it ....ary")
@com.google.gag.annotation.remark.ThisWouldBeOneLineIn(language="groovy", toWit="the method isnt required at all")

From Team:
@com.google.gag.annotation.team.Visionary("this will surely put the Internet back in 90's")
@com.google.gag.annotation.team.Fired(person="asok", reason="well it wasnt his fault")

Well I am enjoying this treat and if you are a gut busting coder I am sure you will also enjoy too. Besides you can also submit your brilliant annotations to the library from the project mailing list.

Another NoSQL Database : FluidDB

2010-03-12T13:53:00.000-08:00

FluidDB is another database in the NoSQL category. It is a cloud based data store and follows the Wiki style approach for data storage. By Wiki style user can create objects in the FluidDB space and modify the existing one. Yet it uses a permission model which differentiates the it from being exact Wiki like.

FluidDB provides HTTP API interface with JSON and provides the HTTP Basic Authentication. FluidDB is in the early private Alpha stage and exposed to only limited number of users. A Sandbox is available where anyone can play with the database and for more detail look one can request the private access by sending the FluidDB Team a Mail request.

FluidDB is basically divided into four parts: 1)User 2)Namespace 3)Tag 4)Object. The User is the primary entity like in any other case. User will create Namespaces, Tags or Objects. Namespace is a logical name and physical separation which primarily describes the Subject the User is interested in like Movie, Sport, Book, etc. Tags are the attributes which describe the subject further in detail like Genre, Year and Awards Tags in Movies Namespace. Tags can exist without Namespaces also like Event, Hot, New can be used irrespective of the subject. Objects are the key entities as they contains actual data. An Object can be created with a String value like http://twitter.com/dhavaln or Die Hard With Vengeance as a topic which can be expressed in detail with various Tags.

An Object can be annotated with Tags from any User or any Namespace. By attaching a Tag to an Object user can provide additional information as a Tag Value for that Object like:

Object: Die Hard With Vengeance
Tags:
  Movie=
  Movie/Genre=Action
  Movie/Year=1995

As you can see same name can be used as a Namespace and as a Tag also. Tag may not contain any value alternatively known as Marker Tags.

FluidDB provides a simple query mechanism through which Objects can be search in the FluidDB space with Tag and Tag values. The following query will return all the Objects having Movie/Year value as 1995.

/Movie/Year = 1995

/Movie/Year > 1995 will return all Objects having Movie/Year value greater than 1995. There are many other conditional approaches provided by FluidDB for searching and can be found here.

Many developers has started using the interesting FluidDB and created API libraries for various languages which can be found here. I have already started using the database with JFluidDB and finding its usefulness in many cases.

The simple HTTP and JSON based interface makes FluidDB widely acceptable in many problem domains in various languages and frameworks.

Spring Roo with NetBeans

2010-03-04T22:32:00.000-08:00

I am a NetBeans user and there are no reason to change the IDE for any tool as NetBeans try to accommodate most of the frameworks and tools. However most of the modern frameworks/tools has easy integration with the Eclipse, Spring Roo is latest in the list. I started evaluating Spring Roo for one of our internal small test application.

Due to the fact that Spring Roo integrated already with Spring Tool Suite (STS) they support using STS IDE for all development. After few here and there i could finally run as well as modify the Spring Roo application in NetBeans IDE.

Maven is a compulsory requirement (until the Ant/Ivy integration is available) for Spring Roo to run, so make sure Maven is configured and NetBeans is referring to the proper Maven repository.

1. Create the project from the Roo Shell and fill the required artifacts for the basic startup.

2. Do perform:eclipse to generate the Eclipse artifacts and open the project in STS

3. Right click on the project and go to the Refactoring, select Push All option. A dialog box will show with number of files, select all the files and click on Ok. This will convert all the AspectJ code (.aj) to pure Java code. This is the point for which Spring Roo is considered to be non-intrusive and you can actually detach the Spring Roo from the application altogether.

4. Open the created application in NetBeans through Import Eclipse Project/Workspace option. Do clean and build and go for Run application. If not configured anything NetBeans will ask for the Web Server which can be selected to installed Apache Server.

Still there are many things in Spring Roo you can not do in NetBeans but for all those things, again one can go back to the command prompt or to the STS for required changes, refactor again and refresh the NetBeans project to take the new changes.

Easyb Revisited - A Groovy based BDD Testing Framework

2010-03-02T02:50:00.000-08:00

easyb is a behavior driven development framework for testing. easyb accepts the Groovy syntax for better explanation of the test scenarios. The first time i encountered easyb, i could not understand the syntactical and semantical sugar but after learning Groovy now i am finding the framework pretty good and useful.

easyb provides two types of templates: one is Ruby RSpac based "it 'should...'" style and another is "given".."when".."then" style. I use the "given.." style because its very explanatory and yet simple make someone understand.

Let's take an example to understand the benefits of the easyb from a programmer and non-programmer's point.

// A utility class to be tested
public class StringList{
   public void add(String element){
   if(element == null){
   throw new RuntimeException("Null values not allowed");
   }
   // add value
   }
}

//easyb story - given..when..then style
scenario "check StringList with null value addition", { // scenario with a reason
   given "an empty StringList", { // what all things available in the scenario
   strList = new StringList()
   }

   when "insert null value", { // what all operations has to be carried out in the scenario
   insertNull = {
   strList.add(null)
   }
   }

   then "a runtime exception should be thrown", { // what should be the result
   ensureThrows(RuntimeException){
   insertNull()
   }
   }
}

//easyb story - it 'should..' style
description 'check StringList with null value addition'

before "initialize the StringList before each spec", {
   strList = new StringList()
}

it "should throw an exception when null value inserted", {
   ensureThrows(RuntimeException){
   strList.add(null)
   }
}

The above stories can be easily divided into two parts one who writes plain test scenarios and another who fills the valid code for testing. No additional knowledge or logic is required to write the test case. An online system can very well generate this kind of templates based on the user input.

// plain test scenario

scenario "check StringList with null value addition", { // scenario with a reason

given "an empty StringList", { // what all things available in the scenario

}

when "insert null value", { // what all operations has to be carried out in the scenario

}

then "a runtime exception should be thrown", { // what should be the result

}

The development or testing team can fill the scenario blocks later with actual code. easyb generates report with pending scenarios and executable scenarios. Pending scenarios are those in which no test code has been added so user can easily identify pending test cases from the reports.

The textual description is right available with the code and is also executable and comes in the result report. The approach helps team members to understand the test cases without much efforts or external documentation.

The easyb comes in a .tar.gz distribution having easyb jar along with Groovy and Apache Commons CLI. So no additional Groovy dependencies are required.

...dev\tdd\easyb>java -cp .;$easyb_home\easyb-0.9.6.jar;$easyb_home\commons-cli-1.2.jar;$easyb_home\groovy-1.6.4.jar org.easyb.BehaviorRunner *.groovy

The above statement will execute all the .groovy files through easyb interpreter BehaviorRunner. There are various switches for detail result of the execution.

easyb generates the result reports in various formats like PlainText, HTML and XML, which can be integrated with any test-case reporting system.

The flexible syntax helps the business analyst and testing team to create test scenarios independent of the development team. A web-based test scenario identification system would be very helpful in generating various kinds of test cases from different users.

I use Netbeans IDE for all my development purpose. There is no plugin available for NetBeans but Eclipse and IntelliJ provides plugin for easyb. For NetBeans one can use the Ant scriptlets provided at Running easyb.

Additional refrences:

bsGrid - A simple HTML/Javascript/jQuery based data grid

2010-03-01T06:04:00.000-08:00

bsGrid is a small javascript/jquery based data grid i have developed for data visualization. The grid is Ajax enabled and for each data operation calls a special service URL.

The grid provides basis functionalities like Sorting, Complex Searching, Paging, Column Freezing, etc. The server to client communication is in JSON so that simple POJOs can be used on the server side.

As of now the code uses Servlet for initial rendering but soon that will be converted to a jQuery Plugin for multiple platform. For other detail refer to the Google Code project site : http://code.google.com/p/bsgrid

Open Source NoSQL Databases

2010-02-23T21:36:00.000-08:00

The article lists open-source databases falls into the NoSQL category. NoSQL is another database paradigm where conventional relational approach and SQL query has no space, rather databases follows the semi-structured, graph based or key-value pair based storage approach for new age social and distributed application requirements.

Enjoy the article.

Google Ambassadors: 45 Essential Google Links

2010-02-20T22:23:00.000-08:00

Google has many well-known and some lesser-known products that everyone who uses Google should be familiar with. The following list has been prepared by Google Ambassadors, a group responsible to promote Google products to Internet users, an explanation about the group activities can be found here.

GWT client with REST

2010-02-20T05:48:00.000-08:00

This article explains a small prototype i developed for a friend to show how REST services can be used can be used from the client code and avoid additional RPC call. The demo explains only two fundamental class structures to access the remote service.

RequestBuilder
GWT client API is having an HTTP request builder class which helps the application to make remote connection through HTTP request and supported methods (GET, POST).

RequestBuilder builder = new RequestBuilder(RequestBuilder.GET, urlAddress);
builder.sendRequest("", new RequestCallback() {

  public void onResponseReceived(Request request, Response response) {
   //use response.getText() to get the resulting text from the service
  }

  public void onError(Request request, Throwable exception) {
   // exception handling
  }
});

XmlParser
GWT client API also provides XML parsing capabilities but to use that XML.gwt.xml has to be included in the modules file.

The following code can parse the XML text and prepare complex node list which can be traversed to access the attributes and node values.

   Document doc = XMLParser.parse(response.getText());

Once Document instance is generated program can start traversal from the root node or can search for the particular nodes based on the name.

   NodeList nodeList = doc.getChildNodes(); // to start from root node
   NodeList nodeList = doc.getElementsByTagName(nodeName); // to start from selected node

Full source code with example services is available here.

Social Databases

2010-02-19T11:11:00.000-08:00

Like many others i am not a big fan of SQL databases available today. But every application needs some or the other ways to persist the information. Being a Java programmer there are many options available to avoid raw SQL interaction during the development through Hibernate, JDO or JPA. But these all at the end lands at relational database only.

Soon i started gaining familiarity with the Google Bigtable and Amazon Dynamo for their non-relational approach and why relational database will not help for their kind of applications. Well the approach was shocking and different but fascinated and proven at the same time. Meanwhile many developers realized that they might need different kind of database altogether to help their applications grow and respond faster.

This realization resulted into many unorthodox, simple yet powerful databases which now-a-days falls into the Social Database category.

Neo4j

Neo4j is a graph database. It is an embedded, disk-based, fully transactional Java persistence engine that stores data structures rather than in tables. The database is quite small in size, approx <500k jar. It provides objected-oriented API to interact with the database.

Besides such a small database, Neo4j provides all the usual database features like ACID transaction, durable persistence, transaction recovery and concurrency control.

For further information you can look out this presentation video and slides by Neo4j creator.

Cassandra

Cassandra is a highly scallable second-generation distributed key-value based database. Initially developed at Facebook and now resides in Apache Incubator. Cassandra combines best features from Amazon Dynamo and Google Bigtable. Cassandra just like Neo4j is tested and proven for high-volume, high-transaction environments. Companies like Facebook, Twitter, Cisco, Mahalo and many more uses Cassandra in their applications.

Cassandra follows the decentralized model where every node in the cluster is having identical information so there is no single point failure. Like many clustered databases, Cassandra follows the Eventually Consistent model and supports advanced features like Read Repair and Hinted Handoff to minimize inconsistency windows.

There are lot of presentations for the same can be found at SlideShare.net.

FluidDB

I have just started my working on this new kind of database. FluidDB is a hosted online cloud database. FluidDB follows the Wiki kind of approach where either user or application can created objects and modify the existing objects. Though it doesn't follow the Wiki model as it is and maintains certain restriction like permission and strict data type. It provides an efficient query mechanism to search through the database. The database provides simple HTTP request API for access.

The database is in the private alpha as of now and you might get an access after sending the FluidDB team a mail API access request. As such i have not explored the database fully but there are plenty of ways this database can be used in today's applications.

Tickery is a simple Twitter based application developed by team FluidDB team for demonstration purpose.

With the growing amount of social applications and their complexities we might see varying amount of databases for different requires over the period of time.

Though these databases will not help you remove the relational databases altogether but will help you deliver the desired complex functionalities fast, easy and with less pain.

Vaadin-Spring Integration

2010-02-18T03:33:00.000-08:00

I remember the time when i was trying to integrate Spring with Struts2 and GWT applications. The problem was rather documenting the integration stuff i tried to remember them and as usual tend to forgot them. So this time have decided to document the Spring integration with Vaadin.

web.xml changes

So first we need to add the Spring Context listener to load the bean configuration file.

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/applicationContext.xml</param-value>

</context-param>

Add the Spring Servlet to intercept Vaadin requests

<servlet-name>VaadinSpringServlet</servlet-name>

<servlet-class>com.dhaval.web.vaadin.spring.servlet.SpringApplicationServlet</servlet-class>

<init-param>

<param-name>applicationBean</param-name>

<param-value>testApplication</param-value>

</init-param>

</servlet>

<servlet-mapping>

<servlet-name>VaadinSpringServlet</servlet-name>

<url-pattern>/vaadin/*</url-pattern>

</context-param>

Spring Servlet

This servlet connects the Spring with Vaadin. The servlet loads the Vaadin Application class and dispatches all the HTTP requests/responses. The Servlet is available in the Simple Application provided by Vaadin Team for Spring integration.

Spring bean configuration

<property>name="driverClassName" value="${db.driver}"/>

<property>name="url" value="${db.url}"/>

<property>name="username" value="${db.user}"/>

<property>name="password" value="${db.pass}"/>

</bean>

<property>name="dataSource" ref="dataSource"/>

</bean>

<constructor-arg>ref="jdbcTemplate"/>

</bean>

<constructor-arg>ref="dao.user"/>

</bean>

testApplication bean id is same as we have given in the web.xml as an init-param to Spring Servlet.

Vaadin Main Application class

This is my Vaadin Application class

public class MyApplication extends Application{

private UserDaoImpl userDao;

public MyApplication(UserDaoImpl userDao){

this.userDao = userDao;

}

public void init() {

Window mainWindow = new Window("Simple Vaadin Spring Integration");

final TextField txtUser = new TextField("Enter username");

Button btnCheckUser = new Button("Check Username");

final Label lblCheckMsg = new Label("");

btnCheckUser.addListener(new Button.ClickListener() {

public void buttonClick(ClickEvent event) {

boolean result = userDao.hasUser(txtUser.getValue().toString());

if(result){

lblCheckMsg.setValue("Available");

}else{

lblCheckMsg.setValue("Not Available");

}

});

mainWindow.addComponent(txtUser);

mainWindow.addComponent(btnCheckUser);

mainWindow.addComponent(lblCheckMsg);

setMainWindow(mainWindow);

}

The full source code is available at vaadin-spring-integration in download section.

Groovy GPath for complex object traversal

2010-02-17T20:54:00.000-08:00

GPath is a path expression language integrated into Groovy which allows parts of nested structured data to be identified and processed. GPath is named after popular XPath functionality to traverse XML nodes. GPath can be used to process XML nodes or composite objects.

class Person{

String firstName

String lastName

int age

}

def personList = [

new Person(firstName: "dhaval", lastName: "nagar", age: 25),

new Person(firstName: "nachiket", lastName: "patel", age: 24),

]

The easiest way to get all firstName from the above collection is to use collect{} closure:

println personList.collect{it.firstName}

// will print ["dhaval", "nachiket"]

But Groovy believes in shortening the most obvious stuff so the above statement can be rewritten like the following the still get the same result.

println personList.firstName

This feature becomes powerful when combined with Regular Expression. The following statement will print all the person whose first name starts with "d".

println personList.firstName.grep(~/d.*/)

// will print ["dhaval"]

However GPath is more popular to parse the XML documents effectively. Here we will take a small XML document and parse it with XmlSlurper and access it's nodes with GPath.

def mylinks = """
<links>
  <link>
   <id>1</id>
   <url>www.google.com</url>
  </link>
  <link>
   <id>2</id>
   <url>www.apple.co.in</url>
  </link>
</links>
"""

def links = new XmlSlurper().parseText(mylinks)

The following statement will print all the URL ending with "com"

println links.link.url.grep(~/.*com/)

The following statement will print all the URL ending with "co.in". One way to escape the . is to surround it with square brackets.

println links.link.url.grep(~/.*co[.]in/)

If my xml document changes radically, its affects my code very slightly.

def mylinks = """

<links>

</links>

"""

To find out urls ending with "com" and "co.in":

println links.link.@url.grep(~/.*com/)

println links.link.@url.grep(~/.*co[.]in/)

@ is the operator to access the property of a node. Parsing XML documents in such an easy way is a dream come true for a Java programmer.

Aardvark - A Valuable Business Tool

2010-02-15T23:40:00.000-08:00

Couple of days before I got a news that Google acquired another popular Internet service called Aardvark in nearly $50 Millions. Aardvark is a social search engine service that connects users live with friends or friends-of-friends who are able to answer their questions. Based on my short interaction with the tool i realized that it can become a great boon for any kind of organizations.

I started using the Aardvark after this news and i found it really good tool to get the answers properly and pretty fast. I am using Yahoo Answers for all my non-technical questions and Stackoverflow for technical questions as I am a software engineer. Though both of these tools are doing pretty well, I was still finding that both the services are missing something.

Now to show Aardvark from an organization perspective, I work in a quite a big organization which employs huge and diversified manpower. Such a big enterprise contains an MIS system to keep employee profile information for future references. However its really hard to keep the latest profile information of each of the employee in the organization.

Every organization generates enormous amount of industry specific problem. When the problem arise they either seek an internal help based on the employee profile information or contact external agencies for support. In any case its time consuming at first and huge investment at the end, in the worst case an organization spends huge money on an external agency who fails to do the job and eventually either the problem is dropped or they find someone from inside.

To not cause such a heavy damage, now a days most of the companies (well software in particular) use Wiki/Forum/Blogs to tackle the situation and spread the knowledge. But this approach is limited to a set of companies and its not interactive. User seeking the information has to search through the set of services to find the answer to his problem.

People tend to learn new things every now and then so their profile keeps on updating compared to organization which prefers to update the profile information every six months or a year. So this approach creates mismatch between the actual employee profile and its organizational print. Because of this match many a times Organization end up hiring brand new resource or seek for some external agency to solve the problem.

Aardvark is a tool which can really bridge the gap between this mismatch. Employee getting new knowledge every now and then can update her profile immediately. Aardvark is intelligent enough in delegating the question to right persons. Such an intelligent and fast communication medium can be used in Enterprises to solve problems immediately without investing further valuable resources.

Well while writing this Aardvark is officially part of Google so in future we might see many new features combined with existing Google services.

Google Buzz - sharing with GMail

2010-02-11T04:13:00.000-08:00

Buzz a new service just announced by Google available under the GMail account. Buzz is designed to share day to day stuffs like text, images, videos, etc. Most of the features are similar to other popular social sharing services apart from the GMail front and other Google services integration.

Following are few buzzes of the Buzz.

Two mode of sharing is available. Public sharing similar to twitter and Private sharing where update is visible to the users of selected group(s)
Many external applications can be configured as a connected sites like YouTube, Google Reader, Picasa, Blogspot, Blogger and Flickr. As such you can paste link having images or videos, Buzz will scan the media files and show you the available contents to select if there are multiple images or videos available. I tried with flickr, vimeo, wikipedia and smashingmagazine
All Buzz entries are available in your Google Profile page under Buzz tab
Any post shared in the Google Reader will be available as a Buzz entry if the Reader is configured as a connected site
A Buzz can be directed to user(s) through '@' symbol before the username like @dhaval.b.nagar@gmail.com
Twitter updates are available as buzz entries if Twitter is configured as a connected site
To create RSS for your own Buzz entries, go to your profile page and select the Buzz tab. Copy the URL and add it in the Google Reader under Add Subscription
Buzz allows to post Link, Images and Videos to entries. Images can be seen with presentation feature on the same page. Videos can be seen live
Each conversation can be seen independently from the Time Link given on the top right of the dialog box
As such you can paste any link on the conversation dialog box and Buzz will find all the available images and videos on the page. You can select at max 4 media content to post.

Overall Buzz falls somewhere between the Google Wave and many other popular social applications. With the failure of Google Wave (or may be Buzz in near future) we will see many such applications trying to fit in the "Social Shoe" from Google.

Groovy Category and Dynamic Overriding

2010-02-10T10:38:00.000-08:00

A Category class is an ordinary class which contains set of methods. The class can be used for a duration of code block and when used first parameter type of each method treats the declared method as its member method.

class TestCategory{

static def test(String str){

return "testing"

}

use(TestCategory){

// test() can be called as a member method inside the use block

assert "testing" == "a".test()

}

A category class can contain method without any parameters but it is not possible to use such method in the use block. A category class method should at least have one parameter to get called from the use block. The following code will throw an exception at the time of execution.

class EmptyMethodCategory{

static def emptyMethod(){

return "empty"

}

use(EmptyMethodCategory){

assert "empty" == emptyMethod()

}

Operator overriding is the most suitable use of the Category classes. In case of operator overriding, if the caller is not matching with any of the overridden methods, original method will be executed.

class StringSumCategory{

static def plus(String str1, String str2){

return str1.toInteger() + str2.toInteger()

}

use(StringSumCategory){

assert 3 == "1" + "2"

assert "12" == "1" + 2

}

If the category class contains a method with only one parameter of type Object, that method will be available to any possible type in Groovy.

class SerializeCategory{

static def serialize(Object obj){

// do serialization stuff

return serializedObj

}

use(SerializeCategory){

println 1.serialize()

println "a".serialize()

println ([1, 2, 3].serialize())

println this.serialize()

println serialize()

}

Groovy is full of surprises. It contains some of the best features from many static and dynamic languages.

Spread operator

2010-02-10T08:41:00.000-08:00

Spread operator helps Groovy collections (list, range and map) to simple comma separated values. Spread operator is so flexible which can be used anywhere. For example:

def test(a, b, c){

return a + b + c

}

def numList = [1, 2, 3]

If you want to pass the above list of values to the test() method you have to write some boilerplate code to extract the elements and pass them in the method.

Whereas the spread operator is introduced to eliminate boilerplate code and follow clean coding. The above method can be called with the given list without a single extra line of code.

test(*numList)

An asterisk followed by list, range or map will spread the collection and convert all the containing values to comma separated values. The above example will work same for Range.

def numRange = 1..3

test(*numRange)

Map has different syntax compared to List and Range.

def aMap = [a:1, b:2]

def bMap = [c:3, *:aMap]

Likewise Groovy contains many such shortening facilities where development time can be reduces and code can remain clear and understandable.

Groovy spread-dot operator in GPath

2010-02-10T06:57:00.000-08:00

GPath is an expression language integrated into Groovy to process nested objects. The dot and spread-dot operators helps to build the GPath expression. The dot operator is used to access the properties and spread-dot operator is used to access property, field or method.

class Person{

String firstName

String lastName

int age

int calc(){

return age * 2

}

def personList = [

new Person(firstName: "dhaval", lastName: "nagar", age: 25),

new Person(firstName: "nachiket", lastName: "patel", age: 24)

]

To access the firstName property one can use either of the operators:

println personList.firstName

// ["dhaval", "nachiket"]

println personList*.firstName

// ["dhaval", "nachiket"]

To access the calc() method spread-dot operator has to be used, whereas dot operator will raise an exception:

println personList*.total()

// [50, 48]

Apart from the access restrictions both the operators works differently when collection contains null values like:

personList << null

personList << new Person(firstName: "sandeep", lastName: "shah", age: 30)

println personList.firstName

// ["dhaval", "nachiket", "sandeep"]

println personList*.firstName

// ["dhaval", "nachiket", null, "sandeep"]

The spread-dot operator will add the null value for each null element in the resulting list.

Both the operators works same when the list element is not null but the requested property is null.

personList.clear()

personList << new Person(firstName: "dhaval", lastName: "nagar", age: 25)

personList << new Person(lastName: "nagar", age: 25)

println personList.firstName

// ["dhaval", null]

println personList*.firstName

// ["dhaval", null]

To avoid such null values in the resulting list, grep expression can be used.

println personList.grep{it?.firstName}.firstName

// ["dhaval"]

Here grep will try to evaluate the true boolean condition, as per the Groovy Truth if an object is NULL it will be considered as FALSE. So above expression will reject all the objects where firstName property value is null.

Calling Groovy closure from Java

2010-02-09T08:53:00.000-08:00

After spending some time with Groovy alone i thought to mix Groovy code with Java. As closures seems the most weird in Groovy i tried to access a closure method from the Java class.

// Groovy code

class ClosureTest{

String firstName

String lastName

def proc(Closure closure){

closure.call(firstName, lastName)

}

// Groovy client

def ct = new ClosureTest()

ct.firstName = "dhaval"

ct.lastName = "nagar"

ct.proc{fn, ln -> println "$fn, $ln"}

// Java client

import groovy.lang.Closure;

class JavaClosureClient{

public static void main(String[] args){

ClosureTest ct = new ClosureTest();

ct.setFirstName("dhaval");

ct.setLastName("nagar");

ct.proc(new Closure(ct){

public Object call(Object[] argument){

System.out.println(argument[0] + ", " + argument[1]);

return null;

}

});

}

Well the difference shows the verbosity of the Java client compared to the Groovy one.

At my workplace we are not in a position to use Groovy extensively but with such silent integration between the two i am sure we can leverage some of the Groovy features.

Dynamic Typing in Groovy

2010-02-09T07:51:00.000-08:00

Groovy like many other features works different from Java when it comes to method binding. Java uses the static binding at compile time to bind the method with the caller based on the parameter types. On the other hand Groovy does method binding at runtime based on the value type of the variable.

Java method binding

public class BindingTest{

public static void main(String[] args){

Object obj1 = 1;

Object obj2 = "hello";

proc(obj1);

proc(obj2);

}

public static void proc(Object obj){

System.out.println("object");

}

public static void proc(String str){

System.out.println("string");

}

At execution, the above Java program will print "object" for both the method calls. The reason is Java does "proc()" method binding based on the variable type defined in the call and ignores the actual values.

On the other hand the same Groovy code will print the output based on the variable values at the runtime.

Groovy method binding

def proc(Object obj){

println "object"

}

def proc(String str){

println "string"

}

proc 1

proc "hello"

The above Groovy program will print "object" followed by "string" output upon execution. This capability makes the code clear and concise. Developer can avoid unnecessary type casting in case of method overriding.

One such boilerplate code a Java programmer has to write while overriding the equals() method, which can be avoided with this approach.

// Java way

public boolean equals(Object obj){

if(!(obj instanceof MyType)){

return false;

}

MyType mt = (MyType) obj;

// do equality check

return result;

}

// Groovy way

public boolean equals(MyType mt){

// do equality check;

return result;

}

The Groovy code is quite simple as no type checking or type casting is involved. Besides if the caller will pass any other type of object; the super class version of equals() will be called and as the base equals() checks identity (==, reference equality), it will return false without any additional line of code.

So such small but effective techniques makes Groovy more popular in Java world.

Java Programmer's first look on Groovy

2010-02-09T04:28:00.001-08:00

Like many Java programmers i started learning Groovy for some fascinated stuffs like Dynamic Typing, Closures, functional programming, etc. Overall the first experience with the Groovy was mind blowing. It has many new things to learn. To start with i am using Groovy in Action, its an excellent book for Groovy beginners.

My first encounter with Groovy started with the conventional "Hello World" program. The Hello World example finished and as such i didn't learn anything.

println "Hello, World"

But meanwhile i found that there are various ways to execute the above groovy code snippet:

1. From command prompt

>groovy -e "println 'Hello, World'"

2. From .groovy file

// HelloWorld.groovy

println "Hello, World"

// on prompt

// .groovy extension is optional

>groovy HelloWorld.groovy

3. From Groovy Interactive Console

// on prompt

>groovyConsole

A GUI application will open where in the upper half part developer can write the Groovy script and on lower half can see the script result.

4. From Groovy Shell

Though i haven't explored the Shell much but i could execute one line at a time and "Hello World" needs one line only. Following is the command to open the Groovy Shell:

// on prompt

>groovysh

Seemingly it would look quite simple to a new learner, but the real magic starts when the above code is either executed by Java interpreter or used by a Java program.

Convert Groovy files to .class files

// on prompt

// .groovy extension is NOT OPTIONAL this time

>groovyc HelloWorld.groovy

And the above command will create a .class file which can be executed with:

// on prompt

>java -classpath .;{groovy home}\embeddable\groovy-all-1.6.7.all.jar HelloWorld

And it works correctly. The same way this class file can be access by any Java program, it can create an instance or call the main() method directly.

So overall my first experience with Groovy was really good and i am quite sure to spend some time with this emerging language.

References

1. Groovy Home

2. Scott Davis' articles on IBM DeveloperWorks

3. Lots of links at Groovy DZone

4. Groovy Magazine

Getting Started with Grails, Second Edition

2010-02-08T04:33:00.000-08:00

The second edition of Getting started with Grails has just released. As the name says the book gives the step-by-step knowledge for the Grails framework and its fundamentals. The book is very well written and a must read for Grails beginners.

Scott Davis and Jason Rudolph both are very well known in Groovy and Grails world. The book will surely help you understand the power of Grails.

The book is available in the infoq.com bookshelf http://www.infoq.com/minibooks/grails-getting-started.

If you are a Groovy/Grails beginners like me, read Mastering Grails article series by Scott Davis at http://www.ibm.com/developerworks/views/java/libraryview.jsp?search_by=mastering+grails

Google Wave Free Account Access

2009-08-02T22:14:00.000-07:00

I received my Google Wave just a day before. But i found not all got this invitation and many are frustrated because they didn't got it and someone from their group has got it.

I am making my wave account open to those who doesn't have, so that they can use the application. This step to not to gain any kind of publicity but to help those who truly want to use.

username: dhaval.b.nagar

password: for password mail me at dhaval.b.nagar@gmail.com

I am a java developer and google fan and hopping everyone going to use this account having the same purpose as i have, to make this much better.

Maven setup behind firewall and NetBeans

2009-07-01T23:45:00.001-07:00

Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project's build, reporting and documentation from a central piece of information.

Installation and Usage guidelines:

Goto the download section of http://maven.apache.org, download and extract it to your apache home folder in your computer (c:\program files\Apache Software Foundation\).
Create listed environment variables:
1. M2 with {Maven folder path}\bin
2. M2_HOME with {Maven folder path}
Update the "PATH" environment with the {Maven folder path}\bin value.

If you are accessing the internet through a Proxy server, you need to provide proxy information to the Maven installation also. Go to the {Maven folder path}\conf, open the settings.xml file and update the proxy value in the following tag:

<proxies>

    <proxy>

      <id>optional</id>

      <active>true</active>

      <protocol>http</protocol>

      <username>{your user name}</username>

      <password>{your password}</password>

      <host>proxy-server</host>

      <port>proxy-server-port</port>

      <nonProxyHosts>127.0.0.1</nonProxyHosts>

    </proxy>

</proxies>

Go to the command promp and type "mvn install", it should start installing basic modules required to run maven in {user home directory}\.m2 folder.
You can change the default home folder path from {user home directory}\.m2 to anything else like "c:\m2" from the {Maven folder path}\conf\settings.xml file by giving the new path in <localRepository> tag. Once you change the path you need to fire the "mvn install" again to generate the basic maven structure or copy it from the old repository structure.
Early NetBeans IDEs are providing the Maven interface with the additional plug-in support. Moreover new IDEs (6.5 onwards) Maven is integrated in the basic installation.
1. NetBeans also required Maven configuration to use integrated or external installation. For external Maven go to the "Tools -> Options -> Miscellaneous -> Maven" and provide external Maven home path.If using the integrated Maven of NetBeans one has to configure the Proxy settings of NetBeans to allow central repository access.
2. You can create Maven project by "File -> New Project -> Maven -> Maven Quickstart Archetype".
3. Sub-project or Third-party dependencies can be easily given by "Add dependency" option in the "Libraries" node of the project.
For further information go to http://maven.apache.org.
Maven encourages the Test Driven Development, so please start understanding and writing the Junit test cases for the code.

Automatic Sequence Diagram with jTracert

2009-02-04T05:52:00.001-08:00

In my early days of programming apart from the usual source people used to expect nice set of system diagrams specially with UML notations. UML, i always used to think, made for a computer scientist and not for a programmer like me. Fuzzy looking notations always turned down my programming exitements.

But soon i realized that documentation plays an important role in a software system. After spending couple of years in the industry i realized the importance of standard software practices. Documentation was my first assignment. By the time i start working on this seriously, i realized that the system is having hundrads of classes having thousands of methods. As the team follows the practice to document each part of the code with code-level comments the task was not that difficult. There are many tool available in the market which can generate diagrams like class, collaboration, dependencies chart, etc.

jTracert is a lightweight, powerful tool to generate sequence diagrams from the running code without thouching any part of the code. It provides online drawing as well as offline drawing. The tool runs as a java agent with the application. jTracert generates diagram script compatible with a Sequence Diagram editor (available in sourceforge.net).

jTracert supports various output file formats like local file system, real time sd server, web file system, etc. It is open source so code modifications can be made to satisfy custom requirements.

http://code.google.com/p/jtracert/