Getting out the Google App Engine Vote for Groovy

I might as well join in the fray of "getting out the vote" for Java/Groovy support in Google App Engine.

If you haven't heard, Google announced a new service: "Google App Engine". It's essentially a hosted application environment that roughly competes with Amazon's EC2 and S3 services. The initial release only supports applications written in Python. But Google has stated that they are looking into support for other languages.

So if you'd like to see Java/Groovy support in Google App Engine, you can vote for it by starring it here:
http://code.google.com/p/googleappengine/issues/list

Simple Java vs Groovy Perfomance Comparison

I recently read a post about doing comparisons with Groovy collections, and there was a snide comment that caught my eye:

Just write a simple helper. I guarantee that it will be 20 times faster than Groovy.

So I wrote some quick and dirty code to test exactly that. It's not scientific by any means, but my simple test showed that the Groovy version was about (edit: 7.5) times slower than the Java version.

That's still slow, but nowhere near as bad as the completely unsubstantiated claim of 20 times slower and not as bad as various other claims I've seen tossed around regarding the Java vs Groovy performance comparison.

And when you consider that Groovy is much younger than Java, that the JVM is only now starting to really get around to optimizations for languages other than Java, and that a main focus of the upcoming Groovy 1.6 release is performance improvements, that's really not bad at all.

For reference, here's the test code and the range of results for several runs. Again, it's a simple test and not scientific, but you can use it to get your own numbers. I'd love to see more people posting comparisons so that we can continue to make a factually based determination of where Groovy performance is slow.

Edit: I changed the Java version to a more compact form using Arrays.asList, increased the interations, and updated my performance numbers accordingly.

Groovy time: between 10781ms and 10688ms
Java time: between 1438ms and 1390ms
Java was roughly 7.5 times faster than Groovy (previous version was only 6 times faster)

GroovyListExamples.groovy:
-------------------------

class GroovyListExamples {

public List listSubtractionTest() {
 def smallList = [1,3,5]
 def bigList = [1,1,1,2,3,4,4,4,5,6,7,7,8,9]
 def result = bigList - smallList
}
}

JavaListExamples.java:
---------------------

import java.util.*;

public class JavaListExamples {

public List listSubtractionTest() {
 List smallList = Arrays.asList(new Object[] { 1, 3, 5});
 List bigList = Arrays.asList(new Object[] { 1,1,1,2,3,4,4,4,5,6,7,7,8,9 });
 return subtractList(bigList, smallList);
}

public List subtractList(List sourceList, List removeList) {
 Set removeSet = new HashSet();
 removeSet.addAll(removeList);

 List result = new ArrayList();
 for (Object item : sourceList) {
  if (!removeSet.contains(item)) {
   result.add(item);
  }
 }
 return result;
}
}

ListExamplesDriver.java:
-----------------------


public class ListExamplesDriver {
public static void main(String[] args) {
 GroovyListExamples groovyWay = new GroovyListExamples();
 JavaListExamples javaWay = new JavaListExamples();

 System.out.println("GROOVY:");
 System.out.println(groovyWay.listSubtractionTest());

 System.out.println("JAVA:");
 System.out.println(javaWay.listSubtractionTest());

 int NUMITERS = 1000000;
 long start, stop;

 start = System.currentTimeMillis();
 for (int i = 0; i < NUMITERS; i++) {
  groovyWay.listSubtractionTest();
 }
 stop = System.currentTimeMillis();
 System.out.println("GROOVY TIME: " + (stop - start) + "ms");

 start = System.currentTimeMillis();
 for (int i = 0; i < NUMITERS; i++) {
  javaWay.listSubtractionTest();
 }
 stop = System.currentTimeMillis();
 System.out.println("JAVA TIME: " + (stop - start) + "ms");
}
}

HTTP Traffic Monitoring and more with Charles

Just stumbled across this post discussing monitoring network traffic for Grails applications. It's not really Grails specific, but I was surprised that my favorite monitoring Swiss Army Knife, Charles, wasn't mentioned until the comments (though to be fair, it is a shareware product costing $50 after the trial).

If you haven't looked at Charles, and you do web development or testing, you should do so. It's basically a local proxy server that gives you a great set of tools for monitoring and manipulating how your applications communicate via HTTP (if you are behind another proxy server, no worries, Charles can delegate it's calls to that proxy server).

You can see the feature list here, but the highlights for me are request/response capturing (the core of the tool), bandwidth throttling (to test applications at various "internet" speeds), and new in the 3.2 release is breakpoint support. Breakpoints are AFAIK a unique feature to Charles and they allow you to "interactively change requests or responses as they pass through Charles".

I also use Charles for a non web development purpose on my laptop to simplify dealing with proxy settings. Basically, I point all applications on my machine to Charles (e.g. Firefox, IE, Eclipse, etc.) and then I just change Charles to enable/disable the use of an external proxy depending on where I'm connected.

Anyway, it's a very useful tool that is well worth checking out.