The last few years saw great advances in alternative languages that target the JVM as their execution environment. JRuby, Scala, Groovy, and Jython emerged as four leading contenders to vie for the attention of developers wanting to master a second JVM language.

The benefits of learning another JVM-bound language are many, according to Frederic Daoud, who writes in a recent blog post, Groovy, (J)Ruby or Scala?:

I've tried out some Groovy, Ruby and Scala (not JRuby), and there are some nice things in there. Most interesting to me is the functional programming and object-oriented programming hybrid aspect. Being able to use existing Java libraries is a definite plus, and unless I'm mistaken ... with JRuby being available, all three languages are now more or less equal in that respect.

There would be several things to consider when choosing a language to learn, besides the language feature set itself; available tools, books, community, marketability.. but let's stick to just the language.

To illustrate the conciseness and syntax of each language, Daoud wrote a simple program in each that iterates over the lines in a set of files provided on the command line:

Groovy:

def MAXLENGTH = 70
args.each { filename ->
    new File(filename).eachWithIndex { line, lineNumber ->
        def length = line.size()
        if (length > MAXLENGTH) {
            println "$filename line=$lineNumber chars=$length"
        }
    }
}

Ruby:

MAXLENGTH = 70

$*.each do |filename|
  File.open(filename) do |file|
    file.each_line do |line|
      length = line.chomp.length
      if length > MAXLENGTH
        puts "#{filename} line=#{$.} chars=#{length}"
      end
    end
  end
end

Scala:

import scala.io.Source
val MAXLENGTH = 70
def process(filename: String) {
    var file = Source.fromFile(filename)
    var counted = file.getLines.counted
    counted.foreach(
        (line: String) => 
            if (line.length - 1 > MAXLENGTH) {
                println(filename + " line=" + (counted.count+1) + " chars=" + line.length)
            }
    )
}
args.foreach(process)

Which of these JVM languages do you think is most useful to learn? And which one is your favorite alternative JVM language?

MAXLENGTH = 70

def process(filename) {
  f = open(filename)
  i = 0
  for line in f:
    i = i + 1
    if len(line) > MAXLENGTH:
      print filename, "line=", i, "chars=", len(line)

for f in sys.argv:
  process(f)

MAXLENGTH = 70
 
def process(filename):
    for i,line in enumerate(open(filename)):      
        if len(line) > MAXLENGTH:
            print filename, "line=", i+1, "chars=", len(line)
  
for f in sys.argv:
    process(f)

MAXLENGTH = 70

ARGF.each{ |line|
   if line.chomp.length > MAXLENGTH
      puts "#{ARGF.filename} line=#{ARGF.lineno} chars=#{line.length}"
   end
}

import java.io.*;
public class LongLines{
   static int MAXLENGTH=70;
   public static void main(String[]args)
         throws Exception{
      for(String arg : args){
         BufferedReader br = new BufferedReader ( new FileReader ( arg ) );
         String line;
         for(int lineNo=0; null != (line=br.readLine()); lineNo++){
            if(line.length()>MAXLENGTH){
               System.out.println(arg+" line="+lineNo+" chars="+line.length());
            }
         }
      }
   }
}

import scala.io.Source
val MAXLENGTH = 70
args.foreach { filename =>
  var file = Source.fromFile(filename)
  var counted = file.getLines.counted
  counted.foreach { line => 
    if (line.length - 1 > MAXLENGTH) {
      Console.println(filename + " line=" + (counted.count+1) + " chars=" + line.length)
    }
  }
}

MAXLENGTH=70

for(f : $args[1..]) {
  line = 0
  readLines(f, function (l) {
    ::line = ::line + 1
    ws = l.endsWith("\r\n") ? 2 : 1
    if (l.length() > MAXLENGTH)
      println(f + " line="+ line +" chars=" +( l.length() - ws ))
  })
}