Lenguajes dependientes de la Java Virtual Machine (JVM)

Un lenguaje de programación dependiente de la JVM es aquel que permite:

• Ejecución en la JVM. 
• Independencia de la plataforma. 
• Gestión automática de memoria. 
• Soporte para múltiples paradigmas. 
• Interoperabilidad. 
• Amplia biblioteca estándar. 
• Compilación a bytecode. 
• Soporte para concurrencia.

Es decir, un programa escrito en un lenguaje de programación dependiente de la JVM podrá ser:

1. Ejecutado en cualquier sistema operativo que cuente con una JVM, sin la necesidad de ser modificado. 
2. Su memoria se autogestionará gracias a un recolector de basura. 
3. Se ejecutará en un entorno seguro, gracias a su modelo de seguridad. 
4. Podrá implementar múltiples paradigmas de programación (estructurada, funcional orientada a objetos, etc.). 
5. Puede emplear librerías creadas en otros lenguajes dependientes, lo que se se conoce como interoperabilidad. 
6. El bytecode generado por la compilación es un código optimizado (optimización JIT), lo que mejora su ejecución y rendimiento. 
7. Permitir el uso de hilos. 
8. Etc.

He aquí una lista de los lenguajes de programación dependientes de la JVM más conocidos, sin tomar en cuenta a Java.

Ballerina

Es un lenguaje de programación de código abierto diseñado por WSO2, enfocado en aplicaciones nativas de la nube y la integración de servicios distribuidos.

https://ballerina.io/

Ceylon

Fue un lenguaje de programación de propósito general con una sintaxis similar a la de Java y C#. Imperativo, estático, estructurado en bloques, orientado a objetos y de orden superior.

https://projects.eclipse.org/projects/technology.ceylon

Actualmente se encuentra congelado. Una lástima, se esperaba mucho de este lenguaje. Al punto de que se creyó, realmente, como el verdadero sucesor de Java.

Concurnas

Es un lenguaje de programación JVM de código abierto diseñado para construir sistemas concurrentes, distribuidos y paralelos confiables, escalables y de alto rendimiento.

https://concurnas.com/

Clojure

Es un lenguaje de programación robusto, práctico y rápido con un conjunto de características útiles que juntas forman una herramienta simple, coherente y poderosa. Se basa en Lisp.

https://clojure.org/

Gosu

Un lenguaje JVM simple, muy simple.

https://gosu-lang.github.io/

Groovy

Es un lenguaje multifacético para la JVM. Su objetivo es proporcionar una experiencia y sintaxis similares a las de Java, pero con funciones de productividad adicionales.

https://groovy-lang.org/

Haxe

Es un lenguaje de programación estrictamente tipado, de alto nivel y código abierto con un compilador cruzado de rápida optimización.

https://haxe.org/

Jabaco

Es un lenguaje de programación dependiente de la JVM que usa como base a Visual Basic.

https://www.jabaco.org/

JRuby

Es una implementación de Ruby en Java.

https://www.jruby.org/

Jython

Se considera como una implementación de Python en Java.

https://www.jython.org/

Kotlin

Es un lenguaje de programación orientado a objetos multiplataforma, estáticamente tipado, de alto nivel y propósito general con inferencia de tipos. Actualmente muy usado para REST APIs y desarrollo de aplicaciones para móviles.

https://kotlinlang.org/

Scala

Es un lenguaje de programación multi-paradigma diseñado para expresar patrones comunes de programación en forma concisa, elegante y con tipos seguros.

https://www.scala-lang.org/

Existen más lenguajes, sin embargo la lista anterior solo incluye los más conocidos.

Enlaces:

https://web.mit.edu/ceylon_v1.3.3/ceylon-1.3.3/doc/en/spec/html_single/
https://codemonkeyjunior.blogspot.com/2024/12/concurnas-un-lenguaje-de-programacion.html
https://alquimistadecodigo.blogspot.com/2024/11/lenguajes-jvm-clojure-groovy.html

Concurnas: un lenguaje de programación JVM

Anteriormente hablamos sobre este lenguaje de programación dependiente de la JVM.

Concurnas es:

"Un lenguaje de programación diseñado para construir sistemas concurrentes, distribuidos y paralelos, confiables, escalables y de alto rendimiento".

Es un lenguaje que se inspira en la sintaxis de Python, por lo que crear un programa en este no será como Java.

Además esta enfocado en la concurrencia, y no secuencial como en los demás lenguajes.

Si quieres saber más, puedes dar un vistazo a un artículo sobre este lenguaje:

https://blogs.oracle.com/javamagazine/post/concurrent-programming-with-concurnas

Programando en Concurnas

Antes de comenzar a hacer tus programas deberás:

1. Tener instalado el JDK 8.
2. Tener la configurada la variable de entorno (JAVA_HOME).
3. Haber instalado Concurnas.

Nota: En versiones superiores al JDK 8 habrá errores.

Recordemos como compilar y ejecutar un programa en este lenguaje:

# Compilar:
concc Programa.conc

# Ejecutar:
conc Programa

Ejemplo 1. El clásico "Hola, mundo".

HolaMundo.conc

System.out.println("Hola, mundo!!")

Compilamos y ejecutamos:

$ concc HolaMundo.conc
$ conc HolaMundo

Ejemplo 2. Crear un programa que muestre los datos de un empleado. Los datos comprenderán: clave de empleado, nombre, edad, fecha de nacimiento, dirección y si estado civil.

Datos.conc

claveEmp String = "345632"
nombre String = "Thomas Muller"
edad int = 18
fecha_nacimiento="23/05/1988"
edo_civil = "Soltero"
direccion= "MonteCarlo no. 45, Barrio Altavista, Toluca."

System.out.println("Clave empleado: "+claveEmp)
System.out.println("Nombre: "+nombre)
System.out.println("Edad: "+edad)
System.out.println("Fecha de nacimiento: "+fecha_nacimiento)
System.out.println("Edo. civil: "+edo_civil)
System.out.println("Dirección: "+direccion)

Como se podrá ver. Hemos definido variables indicado su tipo y en otras se omitió esa indicación. Esta es una de las peculiaridades del lenguaje.

Compilamos y ejecutamos:

$ concc Datos.conc
$ conc Datos

Ejemplo 3. Crear un programa que resuelva operaciones aritméticas básicas: suma, resta, multiplicación y división.

Basicas.conc

/** Definimos las varibles**/
a int = 9
b int = 4
suma int = a + b
resta = a - b
producto int = a * b
division int = a/b

/** Mostramos el resultado en pantalla **/
System.out.println("\t [ Operaciones aritméticas básicas ]");
System.out.printf("Suma de %d + %d da : %d\n",a,b,suma);
System.out.printf("Resta de %d - %d da : %d\n",a,b,resta);
System.out.printf("Producto de %d + %d da : %d\n",a,b,producto);
System.out.printf("División de %d + %d da : %d\n",a,b,division);

Compilamos y ejecutamos:

$ concc Basicas.conc
$ conc Basicas

Ejemplo 4. Crear una clase denominada "Punto" con dos propiedades tipo int, x & y. Mostrar el valor de sus propiedades.

Punto.conc

/** Creamos la clase Punto **/
class Punto{
   public x int
   public y int
   
   this(x int, y int){
      this.x = x
      this.y = y
   }
   
}
/** Instanciamos la clase  Punto **/
var punto = new Punto(4,5);

/** Mostramos el valor de sus propiedades  **/
System.out.println("x: "+punto.x);
System.out.println("y: "+punto.y);

Compilamos y ejecutamos:

$ concc Punto.conc
$ conc Punto

¡Hemos creado nuestros primeros programas en Concurnas!

Continuaremos con el tema en próximas entregas.

Enlaces:

https://codemonkeyjunior.blogspot.com/2020/08/un-lenguaje-de-programacion-lamado.html
https://concurnas.com/
https://blogs.oracle.com/javamagazine/post/concurrent-programming-with-concurnas
https://www.reddit.com/r/ProgrammingLanguages/comments/e8a42b/new_programming_language_concurnas/?rdt=41743
https://devm.io/java/introducing-new-jvm-lanaguage-concurnas-167915

Un lenguaje de programación llamado Concurnas

Concurnas es un lenguaje de programación JVM de código abierto diseñado para construir sistemas concurrentes, distribuidos y paralelos confiables, escalables y de alto rendimiento. A primera vista es muy parecido a Groovy.

La extensión de un programa en Concurnas es *.conc  

Instalación

$ sdk install concurnas

Compilar:

$ concc programa.conc

Ejecutar:

$ conc programa

El Hello, world y otros programas usando Concurnas:

hello_world.conc

System.out.println("Hola, mundo en Concurnas!!")

clases.conc

class X{
   def hola(){
      System.out.println("Hola desde clase X")
   }
}
class Y{
   def hola(){
      System.out.println("Hola desde clase Y")
   }
}

def main(args String[]){
   new X().hola()
   new Y().hola()
}

mayor.conc

def main(args String[]){
  x int = 4
  y int = 2
  System.out.println("x: "+x)
  System.out.println("y: "+y)
  if(x > y){
    System.out.printf("%d > %d \n",x,y)
  }
}

cuenta.conc

def main(args String[]){
	cuenta()
}

def cuenta(){
    suma int = 0
    nombre String = "Polinar Sanchez Umberto"
    palabras String[] = nombre.split(" ")
    System.out.println(nombre)
    System.out.println("Cant. de palabras: "+palabras.length)
    for(cad in palabras){
    	System.out.println(cad+" : "+cad.length())
    	suma = suma + cad.length()
    }
    System.out.println("Cant. de letras: "+suma)
}

operaciones.conc

class X{
	def hacer(args String[]){
		System.err.println("Argumentos: "+args)
	}

	def getLongitud(a String?)=> a?.length()?:'ups'
}

def main(args String[]){
  System.out.println("Hola, mundo en Concurnas!!")	
  new X().hacer(args)

  System.out.println(new X().getLongitud(null))//ups
  System.out.println(new X().getLongitud("null"))//4

  System.out.println("\t***Tipos***")
  entero int 
  entero = 453
  System.out.println("Entero: "+entero)
  System.out.printf("Entero: %d\n",entero)
  cadena String
  cadena = "Este es un buen dia para comenzar."
  System.out.printf("Cadena: %s\n",cadena)
  verdadero Boolean
  verdadero = true
  if(verdadero){
  	System.out.println(new X().getLongitud("Juan Jacobo Rosseau"))
  }

  testA()
  caracter char 
  caracter ='\u1234'
  System.out.println("Caracter: "+caracter)
  class MyClase
  objClase MyClase
  objClase = new MyClase()
  
  if(objClase == null){
  	System.out.println("El objeto es nulo")
  }else{
  	System.out.println("El objeto no es nulo")
  }

  testB()
  testC()

}

def testA(){
	System.out.println("Este es un metodo")
}

def testB(){
  a int = 32
  b int = 21
  c int = 11
  mayor int = a

  System.out.printf("a:%d, b:%d, c:%d\n",a,b,c);
  
  if(mayor < b){
    mayor = b
  }
  if(mayor < c){
    mayor = c
  }
  System.out.println("El mayor es: "+mayor);

}

def testC(){
  System.out.println(mayuscula())
  System.out.println("Suma: "+suma(12,4))
  System.out.println("Decimo: "+decimo())
  System.out.println("Centesimo: "+centesimo())
  System.out.println("Milesimo: "+milesimo())
  //Esto no compilara:
  //cadena String=null
  cadena String="null"
  try{
    cadena = cadena.toUpperCase()
  }catch(npe NullPointerException){
    System.err.println("Ha ocurrido un NullPointerException!!")
  }catch(ex Exception){
    System.err.println("Ha ocurrido una excepcion: "+ex.toString())
    ex.printStackTrace()
  }

  if(verdadero()){
    System.out.println("Suma: "+suma(-32,54))
  }

  falsoFalso Boolean = falso()
  if( not falsoFalso){
    System.out.println("Hola, mundo desde Concurnas!!!")
  }
}

def mayuscula(){
  "mayuscula".toUpperCase()
}

def suma(a int, b int){
  a+b
}

def decimo(){
  1.0/10.0
}

def centesimo(){
  1.0/100.0
}

def milesimo(){
  1.0/1000.0
}

def verdadero()=> true
def falso()=> false

Como se puede observar es muy similar a Java y/o Groovy. En próximos post seguiremos hablando de este lenguaje.

 

Sitio oficial: 

https://concurnas.com