Modern statically typed languages, such as Scala and C# 3.0, provide type inference to reduce the amount of finger typing required of a developer. While dynamic languages often require less finger typing, they are also much harder to optimize during compilation and performance, due to the lack of type information.

In a recent blog post, Duby: A Type-Inferred Ruby-Like JVM Language, JRuby core developer Charles Nutter introduces an experimental language that aims to combine some of the best features of Ruby with the performance attainable in statically-typed code:

We've long wanted to have a "Ruby-like" language, probably a subset of Ruby syntax, that we could compile to solid, fast, idiomatic JVM bytecode. Not a compiler for Ruby, with all the bells and whistles that make Ruby both difficult to support and inefficient to use for implementing itself. A real subset language that produces clean, tight JVM bytecode on par with what you'd get from compiled Java. But better, because it still looks and feels mostly like Ruby...

There are many Ruby features that influence performance negatively even when you're not using them. It's very difficult, for example, to optimally store local variables when the local scope can be captured at any time. So either you rely on tricks, or you store local variables on the heap and deal with them being slow...

When working with a statically-typed language, you can eliminate all of this. In Java, for example, you have both object types and primitive types; primitive operations are extremely fast and eventually JIT down to machine-code equivalents; and the feature set is suitably narrow to allow current JVMs to do amazing levels of optimization...

But of course Java has its problems too. For one, it does very little guessing or "inferring" of types for you, which means you generally have to declare them all over the place. On local variables, on parameters, on return types. C# 3.0 aims to correct this by adding type inference all over, but then there's still other syntactic hassle using any C-like language: curly braces, semicolons, and other gratuitous syntax that make up a lot of visual noise...

Nutter's main motivation in introducing static types, and primitive values, in particular, is performance. He illustrates the performance problems with dynamically-typed code using the following example:

class Foo
  def fib(n)
    if (n < 2)
      n
    else
      fib(n - 2) + fib(n - 1)
    end
  end
end

Wouldn't be nice if we could take the code above, add some type inference logic, and turn it into a fast, static-typed language?

Nutter then introduces his experimental language that aims to provide just that. Using this language, the above code is written as follows:

class Foo
  def fib(n)
    {n => java.lang.Integer::TYPE, :return => java.lang.Integer::TYPE}
    if (n < 2)
      n
    else
      fib(n - 2) + fib(n - 1)
    end
  end
end

Nutter notes that this language is very experimental, but that it may point the way to languages that make better use of type inference:

My working name for this is going to be Duby, pronounced "Doobie", after Duke plus Ruby. Duby! It has a nice ring to it. It may be subject to change, but that's what we'll go with for the moment...

Currently, Duby supports only the features you see here. It's a very limited subset of Ruby right now, and the subset doesn't support all Java primitive types, for example, so there's a lot of blanks to be filled...

What do you think of Duby?

class Fibo {
  def fib(n: Int): Int =
    if (n < 2) n else fib(n - 2) + fib(n - 1)
}

public int fib(int);
  Code:
   Stack=4, Locals=2, Args_size=2
   0:	iload_1
   1:	iconst_2
   2:	if_icmpge	9
   5:	iload_1
   6:	goto	24
   9:	aload_0
   10:	iload_1
   11:	iconst_2
   12:	isub
   13:	invokevirtual	#16; //Method fib:(I)I
   16:	aload_0
   17:	iload_1
   18:	iconst_1
   19:	isub
   20:	invokevirtual	#16; //Method fib:(I)I
   23:	iadd
   24:	ireturn

class FiboTail {

  def fib(n: Int): Int = {

    def aux(n: Int, next: Int, result: Int): Int =
      if (n == 0)
        result
      else
        aux(n - 1, next + result, next)

    aux(n, 1, 0)
  }
}

public int fib(int);
  Code:
   Stack=4, Locals=2, Args_size=2
   0:	aload_0
   1:	iload_1
   2:	iconst_1
   3:	iconst_0
   4:	invokespecial	#25; //Method aux$1:(III)I
   7:	ireturn

private final int aux$1(int, int, int);
  Code:
   Stack=3, Locals=5, Args_size=4
   0:	aload_0
   1:	astore	4
   3:	iload_1
   4:	iconst_0
   5:	if_icmpne	10
   8:	iload_3
   9:	ireturn
   10:	iload_1
   11:	iconst_1
   12:	isub
   13:	iload_2
   14:	iload_3
   15:	iadd
   16:	iload_2
   17:	istore_3
   18:	istore_2
   19:	istore_1
   20:	goto	3

scala> :load dubious.scala
Loading dubious.scala...
defined class Fibo
defined class FiboTail

scala> val fibo = new Fibo
fibo: Fibo = Fibo@ee1c42

scala> val fiboTail = new FiboTail
fiboTail: FiboTail = FiboTail@616fde

scala> for (i <- 1 to 10)
     |   println(fibo.fib(i) + " " + fiboTail.fib(i))
1 1
1 1
2 2
3 3
5 5
8 8
13 13
21 21
34 34
55 55