Constants are the constant things in a project. I mean, it is safe to assume that any project would have some kind of constant values used across the code.

The common practice in Java is to declare them as public, static and final variables so that they can be easily referenced wherever they needed.

Here’s a list of patterns that I have seen on using such constants.

1. Define a Constants class

In this approach, you define a class ‘Constants’ and put all your constants inside this class. Then reference the constants as ‘Constants.CONST_NAME’ wherever needed. Easy as it looks.

public class Constants {
	public static final String SITE_NAME="veerasundar.com";
}

class Hello{
	public void someFun(){
		System.out.print(Constants.SITE_NAME);
	}
}

But the con of this approach is that you need to prepend the class name ‘Constants’ all the time. If you are using constants very frequently, then this will become little ineffective. We can do better.

2. Define a Constants interface and implement it

The second approach is that you define a Interface that contains all your constants and then implement this interface in the class where you want to use the constants. This way, you don’t need to prefix ‘Constants’, instead you can directly access the constant like CONSTANT_NAME.

public interface Constants {
	public static final String SITE_NAME="veerasundar.com";
}

class Hello implements Constants{
	public void someFun(){
		System.out.print(SITE_NAME);
	}
}

But this approach is generally considered as a bad practice because it pollutes the class’s implementation hierarchy. You are forced to implement an interface without much semantic meaning. We can still do better than this.

3. Use Java static imports

Static imports are introduced in Java 5. Using static imports you can import static members/properties of a class so that you can directly access them without prefixing it’s parent class’s name. So, we can define a Constants class as shown in first approach above and the use static imports to use the constant properties directly.

package com.test;
public class Constants {
	public static final String SITE_NAME = "veerasundar.com";
}

import static com.test.Constants.*;
public class Hello {
	public void someFun() {
		System.out.print(SITE_NAME);
	}
}

So, we get the best of both worlds – we don’t unnecessarily prefix Constants everywhere and we don’t pollute class’s API too. Win!

But this approach too has some bad press against it. If you use static imports very often, then your code become hard to read and understand. Especially when you statically import lot of methods. So, use it sparingly and wisely.

What do you think as the best of the above three approaches? Do you use any other approaches other than these? Feel free to comment!

tldr; https://github.com/vraa/twikural

It all started when I asked the following question to my twitter friends:

Juts checking: If there’s a service that sends you a Thirukkural every day, would you be signing up for it?

— Veera (@vraa) January 31, 2012

My idea was simple: to send out Thirukural poems everyday to the people that are signing up for the service. Instead of sending it to email addresses, I decided to use Twitter and Facebook as my medium since that’s where most of the people are hanging out these days.

There were few tweeples responding to it positively. Even though there are already few other alternative services available, I decided to move on and build it as I thought the new service will be different and be a learning experience.

It took a weekend to code the 80% of the site and I hosted it on App Engine platform. And the site is live for the past few weeks – http://twikural.veerasundar.com

Now, the service has 31 followers in Twitter and 37 Likes in Facebook. It has already sent out 120 Thirukurals till date.

And, I’m now open sourcing the code. The project is now hosted @ Github. You are welcomed to check it out and if you’d like to contribute, feel free to send a pull request / contact me.

I would like to thank my fellow tweeples – @iGhillli, @anandhame, @mgobi_php   for their continuous support to this project.

I have started using Sublime text as my preferred code editor (for JS, CSS, Coffee). But, I still rely on Eclipse for writing Java code because it auto-imports Java packages and auto suggests variables and method names from my custom class files.

Working on multiple editors throws in another problem: whenever I make a change in some file outside of Eclipse, the IDE does not silently reload. It shows a blank page saying “The resource is out of sync. Press F5 to reload”. The message started annoying me soon as I had to switch back and forth often.

It is not just for the multiple editors. Even when I do a git pull, the resources go out of sync.

Then, I found a workaround for this. Eclipse provides a built-in option that auto reloads a resource if its out f sync. Here’s how you  can enable it.

Go to Window -> Preferences -> General -> Workspace and check the option “Refresh using native hooks or polling”.

So, the next time when you try to open a out of sync file, the IDE will sync it for you (thus saving you a keystroke, one at a time ).

While browsing the net, I found this problem somewhere – to write a code that tests the given two strings are anagrams or not. From Wiki,

“An anagram is a type of word play, the result of rearranging the letter of a word or phrase to produce a new word or phrase, using all the original letters exactly once; for example orchestra can be rearranged into carthorse.”

I tried to solve this problem using Java and below is the result of it. The algorithm I tried is very simple:

1. Clean the input – remove all the spaces and punctuation marks (because it doesn’t affect the compassion).
2. Go through character by character from string one and check if that character exists in string two.
3. If exists, then remove it from string two and move on to next character. If not exists, then we found a mismatch and the string is not an anagram.
4. If all character from string one exists in string two, then we found it’s an anagram.

 Java code to test two strings are anagrams:

I tested the above code with most of the anagrams found in the Anagram Site and it worked well.

If you think the above code can be improved in someway, feel free to comment.

In any web development company, there exists two different worlds; well there are more, but we’ll just focus on - front end (designers) & back end (developers)

The Front end guys are responsible for making something that is visible to the end users (THE LOOK). The back end guys are responsible for making the front end work (THE FUNCTIONALITY). Together, they both deliver a complete web application/site.

The back end developers would typically use programming languages, such as Java/C++/Python. Apart from talking to database and processing requests, they even have an arsenal of libraries to generate the site markup (JSPs, server side templates, etc).

Front end guys usually fill in by writing HTML documents and CSS files (merely a writer) to present this markup in an visually pleasing way and back end just take these templates to populate data.

Front end had only one option to do any logical operations, by using JavaScript - which has been used for a long time just to validate forms (and do some freaky stuffs).

Because of this cultural difference, there’s always been a ego-war between these two worlds. Even the company management would rate the front end guys par below the back end developers because the front ends guys don’t do any serious programming.

All was going fine until the web2.0 era. Now, the front end realized that they could use JavaScript to do much more cooler stuffs than just the form validation. The development of high speed JavaScript engines (such as V8) made it possible to run complex JavaScript code right in the browser. With the introduction of technologies such as WebGL and Canvas, even graphics rendering became feasible using JavaScript.

But, this didn’t change anything on the server side; the server programs were still running on JVMs/Rubys/Pythons.

Fast forward to today: The scenario is dramatically changing. JavaScript has just sneaked its way into the servers. Now, it is no longer required that a web application needs to have a back end programming language such as Java/C++. Everything can be done using just JavaScript.

Thanks to node.js which made it possible to run the JavaScript on the server side. Using MongoDB, one can replace the need to have SQL code and now store JSON documents using JavaScript MongoDB connectors. The JavaScript template libraries such as {{Mustache}}/Underscore almost removed the need to have server side templates (JSPs). On the client side, JavaScript MVC frameworks such as Backbone.JS enable us to write maintainable code. And, there’s always the plain old JavaScript waiting for us to write some form validation script.

With that, now it is possible to do the heavy lifting just by using JavaScript. The front end JavaScript programmers no longer need to focus on just the front end. They can use their skill set to develop the web application end-to-end.

This rise of the front end developers poses a real threat to the survival of back end developers. If you are one of that back end guy, do you already realize this threat? What’s your game plan to stay fit to survive this challenge?

Right now, when I try to persist an object in Google App Engine, I’m facing the error “Java.lang.VerifyError: Expecting a stackmap frame at branch target“. I’m using JDK 7 and it seems like the problem lies with this JDK.

After googling a bit, I found that there seems to be two solutions to fix this problem.

Solution 1: Change to JDK 6

As simple as is, change your JDK to version 6 and you won’t be bugged by this exception anymore. Well, in my case, I have to use JDK 7. So, moving on to the solution 2.

Solution 2: Configure JVM

Go to Windows -> Preferences -> Installed JREs. Select the default JVM and click edit. Then add this parameter as VM argument “-XX:-UseSplitVerifier” as seen below.

This should solve the issue.

It is often a requirement that you need to connect to a server through HTTP from your android application. When you use servlets/html, making such requests are a no-brainer. But, in Android it needs some searching before implementing such functions.

Here’s some sample code snippets that explains how you can make GET and POST requests from your android application.

Enable Internet permission for your android application:

Before making any use of internet in your android application, you should enable the internet permission for your application. To do this, open the AndroidManifest.xml file and then add the below line:

<uses-permission android:name="android.permission.INTERNET" />

HTTP GET request in Android application:

public static String getHttpResponse(URI uri) {
	Log.d(APP_TAG, "Going to make a get request");
	StringBuilder response = new StringBuilder();
	try {
		HttpGet get = new HttpGet();
		get.setURI(uri);
		DefaultHttpClient httpClient = new DefaultHttpClient();
		HttpResponse httpResponse = httpClient.execute(get);
		if (httpResponse.getStatusLine().getStatusCode() == 200) {
			Log.d("demo", "HTTP Get succeeded");

			HttpEntity messageEntity = httpResponse.getEntity();
			InputStream is = messageEntity.getContent();
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String line;
			while ((line = br.readLine()) != null) {
				response.append(line);
			}
		}
	} catch (Exception e) {
		Log.e("demo", e.getMessage());
	}
	Log.d("demo", "Done with HTTP getting");
	return response.toString();
}

HTTP POST request in Android application:

A POST request is slightly (well, vastly) different from a GET request (I have seen most developers use there requests interchangeably!). In a POST, we often send some parameters to change state of the objects in server.

In Android too, we have some mechanisms to send HTTP parameters while sending a POST request, which is shown in below code snippet.

public static String postHttpResponse(URI uri) {
	Log.d(APP_TAG, "Going to make a post request");
	StringBuilder response = new StringBuilder();
	try {
		HttpPost post = new HttpPost();
		post.setURI(uri);
		List params = new ArrayList();
		params.add(new BasicNameValuePair("paramName", "paramValue"));
		post.setEntity(new UrlEncodedFormEntity(params));
		DefaultHttpClient httpClient = new DefaultHttpClient();
		HttpResponse httpResponse = httpClient.execute(post);
		if (httpResponse.getStatusLine().getStatusCode() == 200) {
			Log.d(APP_TAG, "HTTP POST succeeded");
			HttpEntity messageEntity = httpResponse.getEntity();
			InputStream is = messageEntity.getContent();
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String line;
			while ((line = br.readLine()) != null) {
				response.append(line);
			}
		} else {
			Log.e(APP_TAG, "HTTP POST status code is not 200");
		}
	} catch (Exception e) {
		Log.e(APP_TAG, e.getMessage());
	}
	Log.d(APP_TAG, "Done with HTTP posting");
	return response.toString();
}

To add JSTL to your project;

Download jstl.jar & standard.jar (360KB)

1. Download the jstl.jar and standard.jar files from the above download link (or you can get these from your local Apache Tomcat installation too!)
2. Put them in your project’s WEB-INF/lib folder.
3. Add them to the CLASSPATH.
4. Now you can use JSTL in your pages.

So, why this post about an obvious thing?

Well, I’ve seen people get confused when they try to install JSTL for the first time. They google for “download JSTL or install JSTL” which will end up in the page JSTL downloads (which is surprisingly still hosted at java.sun.com). And, god only knows what you can download from that page!

That is why I’d put together this simple download link. Hope it’ll be useful for the JSTL beginners.

Recently learned a really cool trick for copy-pasting code in Eclipse.

Lets say you have the following code:

package com.veerasundar.demo;

public class CopyCode {
	private int nothing;
}

Now copy the above code, go to any Eclipse project and right click on source folder and paste. See what happens! Impressive isn’t it!?

Here’s what Eclipse did: it parsed the clipboard, found that there’s a Java code in it, create the necessary package structure for the code to fit in and then copied the code there.

Neat!

If you are a Java fan boy, like me, then you have a good news to cheer about. Heroku runs Java now!

Well, unlike other popular ‘web’ languages like PHP/RoR, Java has the legacy of being cumbersome to deploy and maintain in an web server. All this time, only enterprises had the effort to use the Java stack on their web tier. Freelance developers never (or rarely) opted for Java.

But the development of cloud platforms such as Amazon Web Services and Google App Engine has changed the landscape dramatically. Cloud providers managed the hard part of deployment and server management while the developers focused on the application that they are developing. Now pushing a Java app to the wild is just a click-away; at least in GAE it is!

I’d already compiled a list of hosting providers who support Java on their servers. With today’s announcement, Heroku joins the party too.

Even though I’ve not used Heroku before, I’ve read some good reviews about it in Hacker News. With Heroku, all you need to deploy your app is to do a git push! Cool, isn’t it? And, it is not just Java – you can even run the JVM languages like Scala and JRuby.

Moreover, I’m a big fan for the design of their How it works page.

So, if you are developing your app in Java, you have one more hosting provider to consider!