Ceylon, otro lenguaje más para la JVM de parte de RedHat

Tras años y años ganando adeptos sobre todo en el mundo del software comercial, el mundo de Java se haya halla (vaya patinada, ¡gracias por la corrección, Carlos!) bastante movido últimamente. Los desarrolladores parece que buscan alternativas al lenguaje Java en sí por opciones más modernas, sin tener que renunciar a todas las innumerables API que componen el entorno Java, y así, otros lenguajes que compilan a la JVM (Clojure, Scala, Groovy, Jython, etc.) cada vez ganan mayor aceptación.

Dentro de esta tendencia, en RedHat han pensado su propia forma de aprovechar óptimamente las cualidades de la JVM y del propio lenguaje Java en un nuevo lenguaje: lo han llamado Ceylon. (Que resulta, como Java, ser el nombre otra de las islas de la zona del Océano Índico, así que todo encaja.)

De momento lo que sabemos de Ceylon es muy limitado ya que sólo se ha publicado un único PDF con transparencias en las que se explica muy por encima el concepto detrás del lenguaje. No tenemos compilador, ni documentación, ni nada salvo los escasos ejemplos que se muestran en esas transparencias, de los que sin embargo se pueden extraer conceptos muy interesantes.

Lo bueno sin lo malo de Java

Los chicos detrás de este nuevo lenguaje no buscan romper con el paradigma de Java, con su sintaxis, su sistema de objetos, sus tipos estáticos, su filosofía ni con ninguna otra de sus características básicas. Buscan, de alguna forma, una evolución, o más bien una reinterpretación del propósito de Java. Entre las características de Java que destacan como modelo a seguir se encuentran:

• Facilidad, a nivel de sintaxis, legibilidad de código, suave curva de aprendijaze, etc.

• Tipado estático, lo que a pesar de ser a veces un tostón aporta muchas características muy deseables, como la detección de errores en tiempo de ejecución compilación (¡gracias, atoi!) y la instrospección, tanto en tiempo de ejecución como de edición (lo que permite a los IDE implementar cosas como el autocompletado inteligente y la detección de errores sobre la marcha).

• Robustez, que viene dada por características de alto nivel como son la recolección de basura y no tener que preocuparse por punteros y direcciones de memoria, así como el tipado estático ya mencionado o la legibilidad del código sencillamente.

• Pragmatismo, orientación al producto final y al mundo comercial, con una combinación de características que lo hacen óptimo para este ámbito.

A pesar de ello, encuentran multitud de cosas a corregir (bueno, por eso se lanzan a crear un nuevo lenguaje) Entre ellas:

• Verbosidad excesiva, por las características propias del lenguaje: definición de getters y setters, constructores, sobrecarga de métodos, excepciones, arrays, etc.

• Datos estructurados muy dependientes de XML.

• No hay una buena forma de definir interfaces gráficas, a pesar de la multitud de librerías disponibles.

• Falta de modularidad. Java funciona sobre plataformas, no sobre módulos, lo que obliga a elegir a los desarrolladores.

• Librerías no muy bien acabadas, sobre todo el SE SDK.

Nuevas características

De las nuevas características que se incorporan sólo dan unas ligeras pinceladas. Resumo las ideas principales:

• Evita los punteros nulos, esos enemigos de todo javero. Si un objeto puede ser nulo, se especifica su tipo con un ? detrás, y luego se comprueba su existencia con exists:

void hello() {
    String? name = process.args.first;
    if (exists name) {
        writeLine(“Hello “ name ”!”);
    }    
    else {
        writeLine(“Hello World!”);
    }
}

• Nuevos modificadores de atributos: variable para atributos variables (por defecto son inmutables), shared para hacerlo visible desde fuera, local para declaraciones locales. Se elimina el modificador static.

• Nueva sintaxis para getter, setter y constructores, sensiblemente simplificada.

• Los arrays se sustituyen por secuencias, con una sintaxis también muy simplificada y azucarada. Los dos bloques de código siguientes son equivalentes:

Sequence itin = 
        Sequence(“Guanajuato”, “Mexico”, 
           “Vancouver”, “Auckland”,
           “Melbourne”);
String? mex = itin.value(1);
Sequence layovers = 
        itin.range(1..3);
Sequence longer = join(itin, 
        Sequence(“Hong Kong”, “Beijing”));

String[] itin = 
        { “Guanajuato”, “Mexico”, 
           “Vancouver”, “Auckland”,
           “Melbourne” };
String? mex = itin1;
String[] layovers = 
        itin\[1..3];
String[] longer = itin +
        { “Hong Kong”, “Beijing” }

• Funciones de orden superior y closures. ¡Ah, con la programación funcional hemos topado! Las funciones pueden pasarse como argumento a otras funciones, además de existir funciones anidadadas, currificación, definición de funciones por parámetro ad hoc (aunque no hay funciones lambda).

void repeat(Natural times, void perform()) {
    for (Natural n in 1..times) {
        perform();
    }
}

repeat(3, hello);

repeat(3) 
perform() { 
    writeLine(“Hola Mundo!”); 
};

Float add(Float x)(Float y) {
    return x+y;
}

Float addOne(Float y) = add(1.0);
Float three = addOne(2.0);

void aMethod(String name) {
    void hello() { 
        writeLine(“Hello “ name “!”); 
    }
}

• Parámetros con nombre, lo que hace innecesaria la sobrecarga de métodos, reduce la verbosidad y permite definir un lenguaje declarativo plenamente integrado. La funcion repeat anterior se podría invocar así:

repeat { 
    times = 3; 
    void perform() { 
        writeLine(“Hola Mundo!”); 
    }
}

Esto permitiría estructuras tan interesantes como esta:

Html hello {
    Head head { title = “Squares”; }
    Body body {
        Div { 
            cssClass = “greeting”;
            “Hello” name “!” 
        }
    }
}  

De momento poco más se sabe de este nuevo lenguaje. Esperan tener un compilador disponible a lo largo de este año, por lo que la cosa va para rato, pero permaneceremos atentos a este lenguaje que pinta tan interesante.

Vía y más información | Transparencias para QCon Beijing