This document surveys alternative languages that run on the Java Virtual Machine (JVM), including ported languages like JRuby and new languages like Groovy and Scala. It discusses why developers use these languages, noting they provide access to powerful Java platforms and libraries while allowing programming in more modern languages. Issues like performance and compatibility challenges are also outlined. Examples of code in several languages are provided.

1. A Shallow Survey of Alternative
Languages on the JVM
Charles Anderson
March 2013

2. Introduction
● Survey a few languages on the JVM
○ Some philosophy of those languages
● Discuss the value of the Java Platform
● These concepts are applicable to other VM-
based platforms - e.g., Microsoft

3. The Java Language
● Been around for almost 20 years
● Verbose
● Slow to execute
● Slow to start-up
● Slow to evolve
● Very widely used

4. Ported Languages
● A language that was originally implemented
elsewhere - probably C/C++
● Common examples include : JRuby, Jython,
Jacl
● Others (from Wikipedia): Ada, Fortran,
Cobol, Go, etc.

5. Why?
● Because I can
● Research
● Easier than writing to bare metal or C
○ C is portable assembly
○ Java is the new C?
● To leverage the Java Platform

6. The Java Platform
● Java the language
● Java libraries - To Leverage Enterprise
Synergies of Multi-vendor, Standards-
compliant, Powerpoint slide decks
● Java Virtual Machine
○ Performance - JIT
○ Garbage collection
○ Threading
● Tools
● There's a reason Twitter moved a lot of their
system to the JVM

7. Best of Both Worlds
● Get to write in a cool, "new" language (e.g.
Ruby) without leaving the benefits of the
Java Platform
● Many such languages include a REPL
● You can use cool frameworks (e.g.
Cucumber or web apps) with your Java code

8. Issues with Ported Languages
● Owe allegiance to the mother language
○ Leads to impedance mismatches - e.g., JRuby
● Usually, can call into Java easily, but can run
into problems with other combinations - e.g.,
inheritance
● Performance - improving (invoke dynamic)

9. New Languages: Groovy
● Starting from Java, add cool stuff, cut down
on boilerplate - easy transition for Java
programmers
● Strives to be compatible with Java/Platform
● Cool playground for future features of the
Java language - e.g., closures
● http://groovy.codehaus.org/

10. Java or Groovy?
class Book {
private String title;
Book (String theTitle) {
title = theTitle;
}
String getTitle() {
return title
}
}

11. Stupid Pet Tricks
println ‘Hello World’
class MyBean implements Serializable {
String myProp
}
Thread.start { /* some code */ }
coll.each { item-> /* some code */ }
coll.findAll { it % 2 == 0 }.each{ ... }
new File(‘foo.txt’).eachLine { println it }

12. New Languages: Mirah
● Start with Ruby and move back towards
Java
○ static typing and type inference
○ no attempt at Ruby compatibility - no Rails
○ macros and meta-programming
● Very immature - v. 0.1 recently release
● http://www.mirah.org/

13. Little Sample of Mirah
def printN(str:String, n:int)
n.times do
puts str
end
end

14. New Languages: Scala
● Let's create a brand new language
● A hybrid of object-oriented and functional
○ Functional is important for multi-core
● Statically typed with a "dynamic" feel
● Still very compatible with Java/Platform
● http://www.scala-lang.org/

15. Samples of Scala
class Point (var x:int, var y:int)
employees.sort (_.age > _.age)
val s = for (x <- 1 to 25 if x*x > 50) yield 2*x

16. Other New Languages
● Clojure - LISP, functional
● Koitlin - compiles to Java or JavaScript
(from JetBrains/IntelliJ)
● Ceylon from RedHat

17. Conclusion
● You don't have to program in Java to get the
benefit of the Java Platform
● Classic Trojan horse strategy - testing or
other "utility" programming
○ not production
○ not performance critical
○ more productive testing means more real code
○ just a jar file