Lenguajes dependientes de la JVM (3ra parte)

 

Entre los lenguajes dependientes de la JVM (Java Virtual Machine) más conocidos tenemos a:

• Kotlin
• Scala
• Groovy
• Clojure

Kotlin, un lenguaje orientado a objetos, funcional y predilecto para crear aplicaciones Android.

fun main() {
    val holamundo: String = "Hola, Comunidad City Java"
    println("$holamundo")
}

Scala, un lenguaje con paradigmas funcional y orientado a objetos. Donde todo es (realmente) un objeto.

@main
def holamundo() = println("Hola, mundo, Comunidad City Java")

Groovy, un lenguaje dinámico de tipado opcional. Programación funcional, metaprogramación, DSL y scripting.

class TestGroovy{
   def main(args){
       String holamundo = "Hola mundo, Comunidad City Java"
       println "$holamundo"
   }
}

Clojure, un dialecto directo de Lisp. Con interoperabilidad con Java. De propósito general.

(println "Hola mundo, Comunidad City Java")

Sin embargo, existen lenguajes poco o nada conocidos como:

• Ceylon
• Gosu
• Concurnas
• Jython
• JRuby
• Jabaco

Ceylon, el lenguaje que pretendía ser el sucesor de Java y nunca lo fué. Un lenguaje que prometía mucho, pero no concretaba nada. Gavin King lo hizo bien con Hibernate, pero Ceylon fue ese proyecto ambicioso que se quedó para no volver.

void run(){
String[] lenguajes={"Ceylon","Clojure","Groovy","Jabaco","JRuby","Jython","Scala"};
String titulo="*** Lista de lenguajes dependientes de la JVM ***";
print("[Ceylon funcionando correctamente]\n");
print(titulo);
for(lenguaje in lenguajes){
  print(lenguaje);
}
}

Gosu, un lenguaje con una sintaxis similar a la de Groovy (incluso a Javacript).

// Gosu Basics
classpath "."
uses java.util.Calendar
uses java.util.GregorianCalendar
uses java.util.Scanner
uses java.lang.System

class Greet {
    // Fields or Attributes
    var _message: String
    var _name: String
    var _loopMessage: int
    // Properties
    property get Message(): String {
        return _message
    }
    property set Message(value: String) {
        _message = capitalize(value)
    }
    property get Name(): String {
        return _name 
    }
    property set Name(value: String) {
        _name = capitalize(value)
    }
    property get LoopMessage(): int {
        return _loopMessage
    }
    property set LoopMessage(value: int) {
        _loopMessage = value
    }
    // Constructor
    construct() {
        _message = ""
        _name = ""
        _loopMessage = 0
    }
    // Overloaded Constructor
    construct(pmessage: String, pname: String, ploopMessage: int) {
        _message = pmessage
        _name = pname
        _loopMessage = ploopMessage
    }
    // Method 1
    private function capitalize(val: String): String {
        // "if-then-else" statement
        if(val.length >= 1) {
            return val.capitalize()
        }
        else {
            return ""
        }
    }
    // Method 2
    function salute() {
        // "for" statement        
        for (i in 0.._loopMessage) {
            print("${_message} ${_name}!")
        }
    }
    // Overloaded Method 2.1
    function salute(pmessage: String, pname: String, ploopMessage: int) {
        // "while" statement
        var i = 0
        while (i < ploopMessage) {
            print("${capitalize(pmessage)} ${capitalize(pname)}!")
            i = i + 1
        }
    }
    // Overloaded Method 2.2    
    function salute(pname: String) {
        // "switch/case" statement    
        var dtNow = new GregorianCalendar()
        switch (dtNow.get(Calendar.HOUR_OF_DAY))
        {    
            case 6: case 7: case 8: case 9: case 10: case 11:    
                _message = "good morning,"
                break
            case 12: case 13: case 14: case 15: case 16: case 17:
                _message = "good afternoon,"
                break
            case 18: case 19: case 20: case 21: case 22:    
                _message = "good evening,"
                break
            case 23: case 0: case 1: case 2: case 3: case 4: case 5:    
                _message = "good night,"
                break    
            default:    
                _message = "huh?"
        }    
        print("${capitalize(_message)} ${capitalize(pname)}!")
    }    
}

// Console Program
// Define variable object of type Greet and Instantiate. Call Constructor        
var g = new Greet()
// Call Set Properties        
g.Message = "hello"            
g.Name = "world"            
g.LoopMessage = 5
// Call Method 2            
g.salute()        
// Call Method 2.1 and Get Properties            
g.salute(g.Message, "gosu", g.LoopMessage)        
// Call Method 2.2            
g.salute("carlos")            
// Stop and exit            
print("Press any key to exit...")
var sin = new Scanner(System.in)
var line = sin.nextLine()
sin.close()

Concurnas, un lenguaje similar a Scala y Groovy, y que promete estabilidad, seguridad y concurrencia.

msg = {"Hola, mundo en Concurnas!"}! 
System.out.println(msg)

class Holder<X>{
    li = list<X>()

    def add(x X) void {
        li.add(x)
    }
}

hh = new Holder() 
Holder<int>
hh.add(12)
hh.add(33)

Jython, la unión de Python con Java. Si te gusta Python, puedes darle un vistazo.

x = 100;
if (x > 0) {
    System.out.println("Wow, this is Java");
} else {
    System.out.println("Java likes curly braces");
}

JRuby, la unión de Ruby con Java. Ruby no es muy popular y puede que este lenguaje tampoco lo sea.

>> require "java"
=> true
>> h = java.util.HashMap.new
=> {}
>> h.put(:foo, "bar")
=> nil
>> h.get(:foo)
=> "bar"

Jabaco, un IDE y compilador BASIC que depende de la JVM. Para los que programaron en Visual Basic se les hará muy familiar.

Continuaremos con ésta serie de post sobre lenguajes JVM.

Enlaces:

https://play.kotlinlang.org
https://www.scala-lang.org/
https://groovy-lang.org/
https://clojure.org/
https://www.baeldung.com/jvm-languages
https://projects.eclipse.org/projects/technology.ceylon
https://www.jython.org/
https://www.jruby.org/
https://www.jabaco.org/
https://gosu-lang.github.io/
https://concurnas.com/
https://carlosqt.blogspot.com/2010/11/gosu-basics-by-example.html
https://developer.guidewire.com/gosu-programming-language/
https://deployingjruby.blogspot.com/2012/05/zero-downtime-deploys-with-jruby.html
http://railscasts.com/episodes/376-jruby-basics?view=asciicast