List<String> names = Lists.newArrayList();
import static com.google.common.collect.Lists.*;
...
List<String> stuff = newArrayList("Foo","Bar","Baz");
Took : 245 ms, number of elements : 3000000
Took : 278 ms, number of elements : 3000000
Took : 298 ms, number of elements : 3000000
Took : 5140 ms, number of elements : 3000000
Took : 931 ms, number of elements : 3000000
Took : 315 ms, number of elements : 3000000
Took : 1683 ms, number of elements : 3000000
object Scala extends Application {
val absoluteResult = new ArrayList[Any]()
val before = System.currentTimeMillis()
var i =0
while (i<1000000) {
i = i+1
val result = List("foo", 23, true).iterator
while (result.hasNext) {
absoluteResult.add(foo(result.next))
}
}
println("Took : "+(System.currentTimeMillis() - before)
+" ms, number of elements : "+absoluteResult.size)
def foo(obj : Any) =
obj match {
case _:String => "String"
case _:Boolean => "Boolean"
case _:Integer => "Integer"
case _ => throw new IllegalArgumentException()
}
}
(defn foo [x] (cond (number? x) "Number" (string? x) "String" (= (class x) Boolean) "Boolean")) (time (println (count (map foo (apply concat (repeat 10000 ["foo" 23 true]))))))On his machine the Java example takes '31ms' and the Clojure program prints
Prints: 30000 "Elapsed time: 194.046477 msecs"
class XtendWithSwitch {
def static void main(String[] args) {
val absoluteResult = newArrayList()
val before = System::currentTimeMillis()
for (times : 0..1000000) {
val result = newArrayList('foo', 23, true)
for (y : result) {
absoluteResult += foo(y)
}
}
println("Took : "+(System::currentTimeMillis() as int - before)
+" ms, number of elements : "+absoluteResult.size)
}
def static foo(Comparable comp) {
switch(comp) {
String : 'String'
Boolean : 'Boolean'
Integer : 'Integer'
default : throw new IllegalArgumentException()
}
}
}
public static void main(String[] args) {
List<Object> absoluteResult = newArrayList();
long before = System.currentTimeMillis();
for (int i=0; i < 1000000; i++) {
for (Object y : newArrayList("foo", 23, true)) {
absoluteResult.add(foo(y));
}
}
System.out.println("Took : "+(System.currentTimeMillis() - before)
+" ms, number of elements : "+absoluteResult.size());
}
static String foo(Object s) {
if (s instanceof String) {
return "String";
} else if (s instanceof Boolean) {
return "Boolean";
} else if (s instanceof Integer) {
return "Integer";
} else {
throw new IllegalArgumentException();
}
}
Disclaimer: This is probably the worst possible way to compare execution performance. I'm posting it nonetheless since the result was significant. Judge for yourself.
Today I took some time to check out the latest Eclipse plugins for both Groovy and Scala. I mainly wanted to know how nice the tooling is and played around with it a bit. I had been doing some Scala a couple of years ago, but since the Eclipse plugin not even existed those days it was a bit too painful for me to get used to it.
Groovy's tooling looks very good. There are just a few oddities but mainly I think it's well done... in contrast to the Scala plugin (I used 2.0.0 RC4). It holds a lot of surprises. For instance, with the Scala-IDE installed you'll get Scala-related template proposals in the Java and the Groovy editor. Still Scala the language would be my personal choice if I had to decide between the two. Anyway, this post is not about language features or Eclipse-plugin quality, but about what I experienced regarding runtime performance.
I knew Groovy's performance is bad. But I expected the performance problems to diminish, if I use a scenario using dynamic dispatch and mostly untyped objects. So I wrote the following brain dead code:
class Groovy {
public static void main(String[] args) {
def absoluteResult = []
def before = System.currentTimeMillis()
for (times in 1..10000) {
def result = ['foo', 23, true]
for (y in result) {
absoluteResult += foo(y)
}
}
println("Took : "+(System.currentTimeMillis() - before)
+" ms, number of elements : "+absoluteResult.size);
}
static String foo(String s) {
'String'
}
static String foo(Boolean s) {
'Boolean'
}
static String foo(Integer s) {
'Integer'
}
}
It doesn't do anything interesting but leverages Groovy's built-in way of resolving overloaded methods using the runtime type. I thought it's fair to use this feature in a comparison, also because Xtend's dispatch methods have the same behavior. The result of the code above would be a list containing the string 'String', 'Boolean', and 'Integer' each 10.000 times.
When I run this code on my machine, it prints something like the following:
Took : 2025 ms, number of elements : 30000
This is how I could achieve the same using Xtend:
class Xtend {
def static void main(String[] args) {
val absoluteResult = newArrayList()
val before = System::currentTimeMillis()
for (times : 1..10000) {
val result = newArrayList('foo', 23, true)
for (y : result) {
absoluteResult += foo(y)
}
}
println("Took : "+(System::currentTimeMillis() - before)
+" ms, number of elements : "+absoluteResult.size)
}
def static dispatch foo(String s) {
'String'
}
def static dispatch foo(Boolean s) {
'Boolean'
}
def static dispatch foo(Integer s) {
'Integer'
}
}
On a first glance it looks very similar. Note, the dispatch keyword, which turns a set of overloaded methods into dynamically dispatched methods (i.e. the default Groovy behavior).
In contrast to the Groovy version this one is fully statically typed and as it turned out much faster. (Again as you see my measurement technique is everything but professional, but given such a big difference I dare to say it's faster).
It prints something like:
Took : 43 ms, number of elements : 30000
object Scala extends Application {
val absoluteResult = MutableList[Any]()
val before = System.currentTimeMillis()
for (times <- 0 until 10000) {
val result = List("foo", 23, true)
for (y <- result) {
absoluteResult += foo(y)
}
}
println("Took : "+(System.currentTimeMillis() - before)
+" ms, number of elements : "+absoluteResult.size)
def foo(obj : Any) =
obj match {
case _:String => "String"
case _:Boolean => "Boolean"
case _:Integer => "Integer"
case _ => throw new IllegalArgumentException()
}
}
I got this kind of result:
Took : 130 ms, number of elements : 30000
public class Java {
public static void main(String[] args) {
List<Object> absoluteResult = new ArrayList<Object>();
long before = System.currentTimeMillis();
for (int i=0; i < 10000; i++) {
List<Object> result = new ArrayList<Object>();
result.add("foo");
result.add( 23);
result.add(true);
for (Object y : result) {
absoluteResult.add(foo(y));
}
}
System.out.println("Took : "+(System.currentTimeMillis() - before)
+" ms, number of elements : "+absoluteResult.size());
}
static String foo(Object s) {
if (s instanceof String) {
return "String";
} else if (s instanceof Boolean) {
return "Boolean";
} else if (s instanceof Integer) {
return "Integer";
} else {
throw new IllegalArgumentException();
}
}
}
Which prints:
Took : 40 ms, number of elements : 30000
class AppActivity extends Activity {
override void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
contentView = this.linearLayout [
orientation = VERTICAL
view = this.textView ("Hello Android!")
view = this.button ("Click Me!") [
onClickListener = [
this.textMessage('Hello you clicked me!').show
]
]
]
}
}
def static button(Context context, String text,
(Button)=>void initializer) {
val result = new Button(context)
result.text = text
initializer.apply(result)
return result
}
view = this.button ("Click Me!") [
onClickListener = [
this.textMessage('Hello you clicked me!').show
]
]
You should read this, if you are :
In Xtend you could, for instance, add a new method to java.util.List like this:
def static <T> T head(List<T> list) {
for (element : list)
return element
return null
}
Which then can be used as an extension method on any instance of Iterable<T>:
newArrayList(“foo”,”bar”).head()
Using the prefix notation is much closer to how we think, read, and write. From left to right that is. Also the IDE can now provide useful proposals because the receiver is known. The readability gets even better if you use chained method invocations. For instance, let's assume you want to filter the list before obtaining the head. Using the regular infix syntax known from Java the code would like like that :
head(filter(newArrayList(“foo”,”bar”) , [e | e != “foo”]))
But reading inside out doesn’t seem to be the best way to understand what’s going on. So better use extension methods:
newArrayList(“foo”,”bar”).filter(e | e != “foo”).head
Much better, isn't it?
But wait, don’t extension methods advocate the heavy use of static methods? And isn’t that bad coding style?
Yes, often it is.
With static methods you’ll bind your code not only to the signature of a certain method but to the actual implementation. There’s no way (aside from byte code manipulation) to change the implementation without touching the client code. That’s probably not a big deal with the kind of extension methods I just showed. But what if you want to have DAO-like methods available on your domain model types? Accessing them in a static way seems totally uncool, since we wouldn’t be able to run the code with mocks or exchange the database layer easily or just fix or change something later on. That's why static methods are a bad choice most of the time.
Typically you would want to use a dependency injection container to have such services injected. This is where Xtend’s extension methods are different from the one you find in C#.
Xtend allows to use methods from local fields as extension methods.
Let’s assume we have the following Java interface:
interface SaveSupport {
void save(Entity entity);
}
And given we have some domain model type Person which implements Entity, you can write the following code:
class Controller {
@Inject extension SaveSupport
def testStuff() {
val p = new Person()
p.name = “Fred Flintstone”
p.save // translated to ‘this._saveSupport.save(p)’
}
}
That’s a big deal, because now you can use an object oriented coding style but keep your domain model free from layer specific code at the same time! And everything is easily testable and can be run in different scenarios using different DI configuration. There are other unique language features in Xtend, like the template expression, but the combination of extension methods and a good dependency injection framework (Guice) really changes how you structure your software system and reason about it.