Performance comparison of JVM Languages and programming paradigms.

1. JVM Languages – Performance
Comparing the performance of various JVM
languages and programming paradigms.
Corneil du Plessis

2. Introduction
● Programmer since 1985
● Smallest to very large systems.
● Cobol, Pascal, Algol, C/C++, Java, Scala, Groovy and
other JVM languages.
● Scientific instrumentation, Sports event management,
Mining, Banking, Treasury and Insurance.
● Software Architect (coding included)

3. Why a Comparison?
● Multi-paradigm programming
● Code complexity
● Runtime complexity

4. Challenge
● FizzBuzz
– Imperative
– Functional
● Languages
– Java
– Groovy
– Kotlin
– Scala

5. FizzBuzz
● Write a program that prints the numbers from 1 to 100.
● But for multiples of three print “Fizz” instead of the number and for the
multiples of five print “Buzz”.
● For numbers which are multiples of both three and five print “FizzBuzz”
● Pseudo Code
for i in 1 to 100
if i multiple of 15 print ‘FizzBuzz’
else if i multiple of 3 print ‘Fizz’
else if i multiple of 5 print ‘Buzz’
else print i
print newline

6. Imperative Code – Java
public static void imperative(PrintWriter writer) {
for(int i = 1; i <= 100; i++) {
if (i % 15 == 0) {
writer.println("FizzBuzz");
} else if (i % 3 == 0) {
writer.println("Fizz");
} else if (i % 5 == 0) {
writer.println("Buzz");
} else {
writer.println(i);
}
}
}

7. Imperative Code - Groovy
static imperative(PrintWriter writer) {
for(int i = 1; i <= 100; i++) {
if (i % 15 == 0) {
writer.println("FizzBuzz");
} else if (i % 3 == 0) {
writer.println("Fizz");
} else if (i % 5 == 0) {
writer.println("Buzz");
} else {
writer.println(i);
}
}
}

8. Imperative Code – Kotlin
@JvmStatic fun imperative(printWriter: PrintWriter) {
for (i in 1..100) {
when {
i % 15 == 0 -> printWriter.println("FizzBuzz")
i % 3 == 0 -> printWriter.println("Fizz")
i % 5 == 0 -> printWriter.println("Buzz")
else -> printWriter.println(i)
}
}
}

9. Imperative Code – Scala
def imperative(writer: PrintWriter): Unit = {
for (i <- 1 to 100) {
i match {
case x if x % 15 == 0 => writer.println("FizzBuzz")
case x if x % 5 == 0 => writer.println("Buzz")
case x if x % 3 == 0 => writer.println("Fizz")
case x => writer.println(x)
}
}
}

10. Imperative Performance
Language Ops / second % of best
Java 3470211.76 100.00%
Groovy 3457836.97 99.64%
Kotlin 3405441.23 98.13%
Scala 2444048.87 70.43%
Java Groovy Kotlin Scala
0
500000
1000000
1500000
2000000
2500000
3000000
3500000
4000000
Ops / second

11. Functional Code – Java
MapReduce
static class Replacement {
final Predicate<Integer> when;
final String output;
Replacement(Predicate<Integer> when, String output) {
this.output = output;
this.when = when;
}
}
static List<Replacement> fizzAndOrBuzz =
Collections.unmodifiableList(Arrays.asList(
new Replacement(i -> i % 3 == 0, "Fizz"),
new Replacement(i -> i % 5 == 0, "Buzz")
));
static String replace(final Integer i, final List<Replacement> rules) {
return rules.stream()
.filter(r -> r.when.test(i))
.map(r -> r.output)
.reduce(String::concat)
.orElse(Integer.toString(i));
}
static String fizzBuzz(final Integer i) {
return replace(i, fizzAndOrBuzz);
}
public static void functionalMapReduce(final PrintWriter writer) {
IntStream.range(1, 101)
.mapToObj(FizzBuzzFunctionalMapReduce::fizzBuzz)
.forEach((i) -> writer.println(i));
}

12. Functional Code – Java
static class Replacement {
final String output;
final Predicate<Integer> when;
Replacement(Predicate<Integer> when, String output) {
this.output = output;
this.when = when;
}
}
static final List<Replacement> fizzAndOrBuzz =
Collections.unmodifiableList(Arrays.asList(
new Replacement(i -> i % 15 == 0, "FizzBuzz"),
new Replacement(i -> i % 3 == 0, "Fizz"),
new Replacement(i -> i % 5 == 0, "Buzz")
));
static String replace(final Integer i, final List<Replacement> rules) {
final Optional<Replacement> replacement = rules.stream()
.filter(r -> r.when.test(i)).findFirst();
return replacement.isPresent() ? replacement.get().output : i.toString();
}
public static void functional(final PrintWriter writer) {
for (int i = 1; i <= 100; i++) {
writer.println(replace(i, fizzAndOrBuzz));
}
}

13. Functional Code – Groovy
static class Replacement {
Closure when
String output
Replacement(Closure when, String output) {
this.when = when
this.output = output
}
}
static replacements = [
new Replacement({it % 15 == 0}, "FizzBuzz"),
new Replacement({it % 5 == 0}, "Buzz"),
new Replacement({it % 3 == 0}, "Fizz")
]
static String replace(Integer i, List<Replacement> replacements) {
def replacement = replacements.find{ it.when(i) }
return replacement ? replacement.output : i.toString()
}
static functional(PrintWriter writer) {
for(int i = 1; i <= 100; i++) {
writer.println(replace(i, replacements))
}
}

14. Functional Code – Kotlin
class Replacement(r: (Int) -> Boolean, o: String) {
val rule: (Int) -> Boolean = r
val output: String = o
}
val fizzBuzzRules = listOf(
Replacement({ i -> i % 15 == 0 }, "FizzBuzz"),
Replacement({ i -> i % 3 == 0 }, "Fizz"),
Replacement({ i -> i % 5 == 0 }, "Buzz")
)
fun replace(i: Int, replacements: List<Replacement>): String {
val result: Replacement? = replacements.firstOrNull { r -> r.rule(i) }
return result?.output ?: i.toString()
}
@JvmStatic fun functional(printWriter: PrintWriter) {
for (i in 1..100) {
printWriter.println(replace(i, fizzBuzzRules))
}
}

15. Functional Code – Scala
case class Replacement(when: Int => Boolean, val output: String) {
}
val modulusCheck = (i: Int, div: Int) => i % div == 0
val fizzAndOrBuzz = List(
Replacement(i => i % 15 == 0, "FizzBuzz"),
Replacement(i => i % 3 == 0, "Fizz"),
Replacement(i => i % 5 == 0, "Buzz")
)
private def replace(i: Int, rules: List[Replacement]): String = {
rules.find(r => r.when(i)) match {
case Some(r) => r.output
case None => i.toString
}
}
def functional(writer: PrintWriter): Unit = {
for (i <- 1 to 100) {
writer.println(replace(i, fizzAndOrBuzz))
}
}

16. Functional Code – Scalaz
def fizz(n: Int): Option[String] = if (n % 3 == 0) some("Fizz") else None
def buzz(n: Int): Option[String] = if (n % 5 == 0) Some("Buzz") else None
def fizzbuzz(n: Int): String = (fizz(n) |+| buzz(n)).getOrElse(n.toString)
def functional(writer: PrintWriter): Unit = {
for (n <- 1 to 100) {
writer.println(fizzbuzz(n))
}
}

17. Functional Code – Scala Streams
val nones = Stream.continually(None)
val fizzes: Stream[Option[String]] = nones.take(2) ++ Some("Fizz") #:: fizzes
val buzzes: Stream[Option[String]] = nones.take(4) ++ Some("Buzz") #:: buzzes
def functional(writer: PrintWriter): Unit = {
for (((fizz, buzz), n) <- fizzes zip buzzes zip (1 to 100)) {
writer.println(fizz.map(_ + buzz.getOrElse("")).orElse(buzz).getOrElse(n))
}
}

18. Functional Performance
Language Ops / second % of Best
ScalaZ 277517.57 100.00%
Scala 276278.53 99.55%
Kotlin 266858.60 96.16%
Java 124968.78 45.03%
Java MapReduce 85608.05 30.85%
ScalaStreams 47997.63 17.30%
Groovy 13135.39 4.73%
ScalaZ
Scala
Kotlin
Java
Java MapReduce
ScalaStreams
Groovy
0
50000
100000
150000
200000
250000
300000
Ops / second

19. Imperative – Java Call
private static String replace(int i) {
if (i % 15 == 0) {
return "FizzBuzz";
} else if (i % 3 == 0) {
return "Fizz";
} else if (i % 5 == 0) {
return "Buzz";
} else {
return Integer.toString(i);
}
}
public static void imperative(PrintWriter writer) {
for(int i = 1; i <= 100; i++) {
writer.println(replace(i));
}
}

20. Imperative – Groovy Call
static String replace(int i) {
if (i % 15 == 0) {
return "FizzBuzz"
} else if (i % 3 == 0) {
return "Fizz"
} else if (i % 5 == 0) {
return "Buzz"
} else {
return Integer.toString(i)
}
}
static imperative(PrintWriter writer) {
for(int i = 1; i <= 100; i++) {
writer.println(replace(i))
}
}

21. Imperative – Kotlin Call
fun replace(i: Int): String {
when {
i % 15 == 0 -> return "FizzBuzz"
i % 3 == 0 -> return "Fizz"
i % 5 == 0 -> return "Buzz"
else -> return i.toString()
}
}
@JvmStatic fun imperative(printWriter: PrintWriter) {
for (i in 1..100) {
printWriter.println(replace(i))
}
}

22. Imperative – Scala Call
def replace(i: Int): String = {
return i match {
case x if x % 15 == 0 => "FizzBuzz"
case x if x % 5 == 0 => "Buzz"
case x if x % 3 == 0 => "Fizz"
case x => x.toString
}
}
def imperativeCall(writer: PrintWriter): Unit = {
for (i <- 1 to 100) {
writer.println(replace(i))
}
}

23. Comparing function optimization
Language Ops / second % of best
Java 667866.64 100.00%
Groovy 641418.92 96.04%
Kotlin 623649.03 93.38%
Scala 498185.74 74.59%
Java Groovy Kotlin Scala
0
100000
200000
300000
400000
500000
600000
700000
800000
Ops / second

24. Comparing Paradigms
Paradigm Ops / second % of Best
Imperative Inline 3194384.71 100.00%
Imperative Call 644311.53 20.17%
Functional Static 236405.87 7.40%
Functional Streams 66802.84 2.09%
Functional Dynamic 13135.39 0.41%
Imperative Inline
Functional Static
Functional Dynamic
0
500000
1000000
1500000
2000000
2500000
3000000
3500000
Ops / second

25. Summary
● A trivial example doesn’t always tell the whole story.
● Function call overhead cannot be discounted.
● Reducing Code Complexity is sometimes more important than
reducing Runtime Cost.
● Java Closures does not seem to perform as well as Kotlin or
Scala equivalents.
● Kotlin is a an awesome way to reduce complexity and
programmer errors.
● Groovy is a dynamic language.
● Scala was sent by ‘Aliens’.

26. Questions
● More information
– https://github.com/corneil/compare-fp
● Contact
– @corneil
– corneil@jumpco.io