Download - Performance Comparison JVM Languages
Ops / second
Java3470211.76
Groovy3457836.97
Kotlin3405441.23
Scala2444048.87
Ops / second
ScalaZ277517.57
Scala276278.53
Kotlin266858.6
Java124968.78
Java MapReduce85608.05
ScalaStreams47997.63
Groovy13135.39
Ops / second
Imperative Inline3194384.71
Imperative Call644311.53
Functional Static236405.87
Functional Streams66802.84
Functional Dynamic13135.39
Ops / second
Java667866.64
Groovy641418.92
Kotlin623649.03
Scala498185.74
JVM Languages Performance
Comparing the performance of various JVM languages and programming paradigms.
Corneil du Plessis
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)
Why a Comparison?
Multi-paradigm programming
Code complexity
Runtime complexity
Challenge
FizzBuzzImperative
Functional
LanguagesJava
Groovy
Kotlin
Scala
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
Imperative Code Java
public static void imperative(PrintWriter writer) {
for(int i = 1; i printWriter.println("Fizz")
i % 5 == 0 -> printWriter.println("Buzz")
else -> printWriter.println(i)
}
}
}
Imperative Code Scala
def imperative(writer: PrintWriter): Unit = {
for (i 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)
}
}
}
Imperative Performance
LanguageOps / second % of best
Java3470211.76100.00%
Groovy3457836.9799.64%
Kotlin3405441.2398.13%
Scala2444048.8770.43%
Functional Code Java MapReduce
static class Replacement {
final Predicate when;
final String output;
Replacement(Predicate when, String output) {
this.output = output;
this.when = when;
}
}
static List 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 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));
}
Functional Code Java
static class Replacement {
final String output;
final Predicate when;
Replacement(Predicate when, String output) {
this.output = output;
this.when = when;
}
}
static final List 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 rules) {
final Optional 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 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): 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))
}
}
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 "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