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