Mirah (programming language)

Mirah
Paradigm object-oriented, imperative
First appeared 2008
Typing discipline static, with dynamic features, strong, inferred
License Apache 2.0
Website http://www.mirah.org/
Influenced by
Ruby, Java, Boo

Mirah (formerly known as Duby) is a programming language based on Ruby syntax, local type inference, hybrid static/dynamic type system, and a pluggable compiler toolchain. Mirah was created by Charles Oliver Nutter to be "a 'Ruby-like' language, probably a subset of Ruby syntax, that [could] compile to solid, fast, idiomatic JVM bytecode."[1] The word mirah refers to the gemstone ruby in the Javanese language, a play on the concept of Ruby in Java.[2]

History

In order to foster more participation in the JRuby project from Ruby community members, Nutter began to explore the possibility of presenting Ruby syntax, but with a static type model and direct-to-native compilation. In this context, "native" meant primarily the JVM, but Mirah has been designed around the possibility of having alternative backends for other object-oriented runtimes like the CLR. The language needed to look and feel like Ruby, but without introducing any new library dependencies into JRuby (which ruled out most other JVM languages) and without suffering a performance penalty (which meant writing in Ruby itself was out).

Early versions of Mirah (then Duby) focused mostly on mathematical performance, where dynamic languages often pay the highest cost. Since then it has evolved into a full-fledged JVM language, with several users and real-world applications using it for core components.

Design

Mirah is largely just a pluggable compiler toolchain. The primary elements of this toolchain are:

  1. A parser, based on JRuby's parser, that produces a Ruby AST
  2. A transformer that converts the Ruby AST into a Mirah AST
  3. A type inferrer that decorates the Mirah AST with appropriate typing information for the target backend
  4. A backend code generator

Of these phases, only the last two require specific knowledge of the eventual target platform. This makes Mirah suitable for many backends, and also makes it possible to write language plugins for Mirah's transformation phase that will apply to all supported backends equally.

For simple pieces of code and the JVM bytecode backend, the Mirah compiler will produce nearly the same instructions as standard javac compilers.

No runtime library

Because Mirah is just a compiler, it ships no standard library. The intent is that Mirah users will choose what libraries they want to use, perhaps write plugins for the Mirah compiler to support them, and the compiler will do the rest. This is an explicit design goal, avoid introducing a requirement on any new external library. The standard library for Mirah, then, is whatever the standard library for the current backend is, and emphasis is placed on writing compiler plugins rather than libraries to extend and enhance the language.

Type system

Mirah does not impose a specific type system on users, instead relying on whatever the target backend provides. On the JVM, the type system is largely Java's type system, and type declarations refer to JVM classes, primitives, and interfaces.

Mirah is primarily a statically-typed language, but support is in development to allow dynamic typing as well. The mechanism is similar to that provided in C# 4, with a special "dynamic" type indicating all dispatches against that variable's value should be done dynamically. Dynamic type support is currently planned only for Java 7 and higher, using the new invokedynamic bytecode.

Syntax

The syntax of Mirah is largely the same as the syntax of Ruby, but with a few modifications to support static typing:

def foo(a:String, b:int)

Outside of these differences, Mirah code generally looks like Ruby code:

def fib(a:int)
  if a < 2
    a
  else
    fib(a - 1) + fib(a - 2)
  end
end

Status

Currently Mirah is under development, but there are developers using Mirah for production applications on a limited scope.

Frameworks

Dubious

Dubious is a project for running Mirah on Google App Engine. Dubious provide a way to build apps in Mirah, with conventions familiar to Rails and Sinatra developers. Since everything is compiled ahead-of-time Mirah apps have none of the initialization costs associated with JRuby. Dubious supports ERb and has a simple datastore adapter that uses a syntax similar to Datamapper.

References

External links

This article is issued from Wikipedia - version of the Saturday, April 25, 2015. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.