The document compares the performance of different programming paradigms and JVM languages for solving the FizzBuzz problem. It finds that imperative code with inline logic has the best performance, while functional programming with streams has the worst performance. Kotlin and Scala generally perform comparably to Java, while Groovy's dynamic nature makes it slower. The key takeaways are that trivial examples don't tell the full story, function call overhead is significant, and reducing code complexity may be more important than raw performance in many cases.

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