GraalVM + sistema operativo = GraalOS

GraalOS es una iniciativa experimental que integra la tecnología de GraalVM directamente en el sistema operativo, permitiendo que las aplicaciones, especialmente las desarrolladas en lenguajes JVM (Java, Scala, Kotlin), se ejecuten de manera más eficiente y directa sobre el hardware. GraalOS busca ser un sistema operativo minimalista y optimizado para ejecutar aplicaciones de alto rendimiento, proporcionando un entorno ideal para microservicios, procesamiento en la nube y aplicaciones en tiempo real.

Las principales características de GraalOS son: 

1. Soporte Nativo para Lenguajes JVM: GraalOS permite ejecutar código de JVM directamente sobre el sistema operativo sin capas intermedias, ofreciendo un rendimiento nativo para lenguajes como Java, Kotlin y Scala.
2. Integración con GraalVM: GraalOS está construido sobre la base de GraalVM, lo que permite la compilación AOT (Ahead-of-Time) y el uso de `native-image` para generar binarios nativos que corren eficientemente sobre el hardware.
3. Ecosistema Multilenguaje: Aunque está optimizado para lenguajes de la JVM, GraalOS también soporta otros lenguajes como JavaScript, Python y R, aprovechando la compatibilidad de GraalVM.
4. Optimización para Microservicios: GraalOS está diseñado para ejecutarse en contenedores ligeros, ideales para arquitecturas de microservicios y entornos de computación en la nube.

Uno de los puntos fuertes de GraalOS es el uso de la tecnología de compilación Ahead-of-Time (AOT) de GraalVM. La compilación AOT permite que el código de JVM se convierta en código nativo, lo cual mejora significativamente el tiempo de inicio y reduce el uso de memoria.

native-image -jar tu_aplicacion.jar

Este comando convierte un archivo JAR en un binario nativo, optimizado y listo para ejecutarse en GraalOS. Los binarios nativos generados pueden arrancar casi instantáneamente y son ideales para aplicaciones que requieren respuesta en tiempo real.

GraalOS ofrece un entorno perfecto para el despliegue de aplicaciones en la nube gracias a su integración optimizada con GraalVM. Además, permite manejar aplicaciones en tiempo real gracias a su bajo tiempo de respuesta y consumo de recursos. Su diseño minimalista y eficiente hace que sea una opción atractiva para desarrolladores que busquen optimizar costos y rendimiento en entornos de microservicios o serverless.

Aunque GraalOS es experimental, se puede probar en entornos de contenedores o como un sistema operativo en máquinas virtuales para evaluar su rendimiento en aplicaciones específicas. Para comenzar, puedes instalar GraalOS en una máquina virtual y luego utilizar GraalVM para compilar y ejecutar aplicaciones.

apt update && apt install graalos

GraalOS representa un avance en la forma en que interactuamos con el hardware a nivel de sistema operativo para ejecutar aplicaciones nativas. Aunque en sus primeras etapas, su integración con GraalVM abre la puerta a nuevas oportunidades en la ejecución de aplicaciones de alto rendimiento y microservicios en la nube.

Con una promesa de rendimiento optimizado, tiempos de respuesta ultrarrápidos y soporte multilenguaje, GraalOS podría transformar la forma en que desarrollamos e implementamos aplicaciones nativas.

Dejo like : 

https://blogs.oracle.com/java/post/introducing-graalos

https://graal.cloud/

Programación poliglota con GraalVM parte 2

Seguimos con GraalVM 

Veamos un ejemplo queremos ejecutar una aplicación javascript o node que dentro llama a codigo ruby, por ejemplo. 

Vamos a tener que crear un archivo .js que lo llamaré ejemplo.js que contenga lo siguiente: 

var array = Polyglot.eval("ruby", "[1,2,42,4]")

console.log(array[2]);

Y lo ejecutamos con : 

js --polyglot --jvm ejemplo.js

42

node --polyglot --jvm ejemplo.js

42

Así de fácil o queremos ejecutar en una aplicación R, javascript :

array <- eval.polyglot("js", "[1,2,42,4]")

print(array[3L])

Y lo corremos con : 

Rscript --polyglot --jvm ejemplo.R

[1] 42

Y puedo seguir con ejemplos pero creo que se entiende :D

Dejo link : https://www.graalvm.org/reference-manual/polyglot-programming/#running-polyglot-applications

¿Cuantas jdks usables existen?

Me pregunte cuantas Jdks existen, normalmente trato de usar la de oracle, solo por costumbre o adoptOpenJDK. Solo por costumbre, no por ser fanático, y me pregunte cuantas o cuales podría utilizar y me encontré con esta amplia lista : 

JDK	PROVIDER	AVAILABLE VERSIONS	MISCELLANEOUS
Oracle JDK	Oracle	7 8 9 10 11 12 13 14 15 16-ea	Builds for different Java projects under development: Lanai: Implements a new Java 2D graphics rendering pipeline for macOS Loom: I already touched the subject in a previous post Metropolis: Use Graal in form of the native library, instead of C2 as HotSpot high optimizing JIT compiler Panama: Test a prototype implementation of the native binder Valhalla: Test a prototype implementation of L-World Inline Types
Adoptium	Eclipse	8 9 10 11 12 13 14 15	Choice of traditional HotSpot vs. OpenJ9 Recent rebranding of AdoptOpenJDK
Dragonwell	Alibaba	8 11	According to their own words: Optimized for online e-commerce, financial, logistics applications running on 100,000+ servers Supports Linux/x86_64 platform only
Corretto	Amazon	8 11 15
Zulu	Azul	6 7 8 9 10 11 12 13 14 15 16-ea	Zulu Mission Control: Monitoring and Management for Java Applications Zulu OpenJDK Discovery API: Programmatically fetch lists of OpenJDK builds Azul provides an Alpine-compatible Docker image
Liberica	BellSoft	8 9 10 11 12 13 14 15	REST Product Discovery API Liberica provides two Alpine-compatible Docker image: one for glibc one for musl
Red Hat build of OpenJDK		8 9 10 11 12 13 14 15
Sap Machine	SAP	11 15 16-ea	Features contributed by SAP

Y ojo que falta en esta lista GraalVM que lo he usado para unas pruebas y anda joya. 

GraalVM 21.3 soporta Java 17

Oracle Labs lanzó GraalVM 21.3, que ofrece soporte para Java 17 y JDK Flight Recorder (JFR) para la generación de perfiles de producción de bajo costo de ejecutables nativos de Java. En comparación con la versión 21.1 de abril de 2021, esta versión crea ejecutables nativos un 14% más pequeños para Spring PetClinic JDBC con un 20% menos de tiempo de compilación. La versión ejecuta aplicaciones más rápido y comienza a admitir Java Platform Module System.

GraalVM también inicia aplicaciones Java no nativas interpretadas más rápido ahora. Esto ayuda durante el desarrollo donde la ejecución de ejecutables nativos de Java no es práctica debido a los largos tiempos de compilación.

GraalVM viene en dos ediciones: Community Edition y Enterprise Edition. La licencia GPL de Community Edition con "Classpath" Exception significa que es "de uso gratuito para cualquier propósito y viene sin condiciones, pero tampoco garantías ni soporte". Sus lanzamientos reciben actualizaciones durante un año. Enterprise Edition requiere la suscripción a Oracle Java SE para uso en producción, pagada por usuario o por procesador.

Enterprise Edition también incluye soporte de Oracle y tiene características exclusivas de rendimiento y seguridad, como optimizaciones guiadas por perfiles y el recolector de basura G1. Es por eso que sus ejecutables nativos alcanzan el 98% del rendimiento de OpenJDK en una combinación de referencia frente al 43% con la Community Edition, todo mientras usan menos memoria y se inician más rápido que las aplicaciones OpenJDK.

Oracle afirma que los ejecutables nativos de Enterprise Edition son incluso hasta un 40% más rápidos que OpenJDK en algunos escenarios de aprendizaje automático. Constant Blinding es un ejemplo de una función de seguridad en Enterprise Edition. Defiende contra ataques de pulverización JIT y se puede habilitar con -Dgraal.BlindConstants = true.

Una nueva opción de configuración en tiempo de compilación para ejecutables nativos permite deshabilitar funciones como la reflexión, JNI, objetos de proxy dinámico y excluir los recursos de classpath si no se puede acceder a una clase. Eso puede llevar a ejecutables nativos más pequeños.

La nueva proftool (Linux solo por ahora) recopila métricas de rendimiento en tiempo de ejecución de aplicaciones Java de JVM, la herramienta perf de Linux y HotSpot LogCompilation. Esto ayuda con el análisis de rendimiento JIT.

GraalVM Polyglot Runtime ejecuta varios lenguajes además de Java. El tiempo de ejecución de JavaScript se actualizó a Node.js 14.17.6 y mejoró su compatibilidad con WebAssembly. El tiempo de ejecución de Python ahora puede ejecutar paquetes binarios de HPy sin volver a compilarlos. También admite el módulo de multiprocesamiento para orquestar tareas en múltiples contextos de Python en una máquina de múltiples núcleos y tiene un módulo de socket escrito en código nativo.

Ruby en GraalVM ahora usa TRegex, un motor de expresión regular más eficiente, y es hasta 9 veces más rápido en algunos puntos de referencia. El tiempo de ejecución de R actualizado de PCRE a PCRE2 versión 10.37. La cadena de herramientas LLVM para compilar C / C ++ se actualizó a la versión 12.0.1. Y WebAssembly se ejecuta más rápido en algunos escenarios en GraalVM Enterprise Edition.

Las herramientas de GraalVM mejoradas en Visual Studio Code: las herramientas de GraalVM para Java se pueden adjuntar a ejecutables nativos para la depuración. Y las herramientas GraalVM para Micronaut pueden implementar, ejecutar y depurar aplicaciones Micronaut en un clúster de Kubernetes.

Spring Native, una nueva iniciativa de Spring, crea ejecutables nativos para aplicaciones Spring. La versión 0.11, cuyo lanzamiento está programado para el 19 de noviembre de 2021, se basará en GraalVM 21.3 y el próximo lanzamiento de Spring Boot 2.6. La pila Java nativa de Kubernetes Quarkus utilizará GraalVM 21.3 como la versión recomendada en la próxima versión 2.5. El marco de pila completa Micronaut admitirá oficialmente GraalVM 21.3 con el próximo lanzamiento de la versión 3.2.0 programado para fines de noviembre o diciembre de 2021.

Dejo link: https://medium.com/graalvm/graalvm-21-3-is-here-java-17-native-image-performance-updates-and-more-ac4cbafcfc05

Creando la primera aplicación con Quarkus parte 4

Seguimos con quarkus

Ahora vamos a empaquetar nuestra app, lo hacemos con gradle jar y la ejecutamos con 

java -jar build/quarkus-app/quarkus-run.jar

y listo tenemos nuestra app andando en http://localhost:8080/hello 

El directorio quarkus-app que contiene el archivo jar quarkus-run.jar, que es un jar ejecutable. Pero no tiene todas las dependencias estas se copian en subdirectorios de quarkus-app/lib /. Por lo tanto debemos deployar todo el directorio quarkus-app la primera vez y cada vez que hay cambio de librerías. 

Bueno, ya estamos! con esto tenemos nuestra app andando pero vamos a hacer un paso más vamos a hacer nuestra applicación nativa. Para eso debemos utilizar GraalVM 11. 

La construcción de un ejecutable nativo requiere el uso de una distribución de GraalVM. Hay tres distribuciones: Oracle GraalVM Community Edition (CE), Oracle GraalVM Enterprise Edition (EE) y Mandrel. Las diferencias entre las distribuciones de Oracle y Mandrel son las siguientes:

Mandrel es una distribución descendente de Oracle GraalVM CE. El objetivo principal de Mandrel es proporcionar una forma de crear ejecutables nativos diseñados específicamente para admitir Quarkus.

Las versiones de Mandrel se crean a partir de una base de código derivada de la base de código anterior de Oracle GraalVM CE, con solo cambios menores pero algunas exclusiones importantes que no son necesarias para las aplicaciones nativas de Quarkus. Admiten las mismas capacidades para crear ejecutables nativos que Oracle GraalVM CE, sin cambios significativos en la funcionalidad. En particular, no incluyen soporte para programación políglota. El motivo de estas exclusiones es proporcionar un mejor nivel de soporte para la mayoría de los usuarios de Quarkus. Estas exclusiones también significan que Mandrel ofrece una reducción considerable en su tamaño de distribución en comparación con Oracle GraalVM CE/EE.

Mandrel está construido de forma ligeramente diferente a Oracle GraalVM CE, utilizando el proyecto estándar OpenJDK. Esto significa que no se beneficia de algunas pequeñas mejoras que Oracle ha agregado a la versión de OpenJDK utilizada para crear sus propias descargas de GraalVM. Estas mejoras se omiten porque OpenJDK no las gestiona y no puede responder por ellas. Esto es particularmente importante cuando se trata de conformidad y seguridad.

Actualmente, Mandrel solo se recomienda para compilar ejecutables nativos destinados a entornos Linux en contenedores. Esto significa que los usuarios de Mandrel deben usar contenedores para construir sus ejecutables nativos. Si está creando ejecutables nativos para plataformas de destino macOS o Windows, debería considerar usar Oracle GraalVM en su lugar, porque Mandrel no se dirige actualmente a estas plataformas. Es posible compilar ejecutables nativos directamente en Linux.

Los requisitos previos varían ligeramente dependiendo de si está utilizando Oracle GraalVM CE/EE o Mandrel.

Primero, tenemos que configurar las variables de entorno JAVA_HOME y GRAALVM_HOME (y tener instalado docker). 

Y luego tenemos que hacer : 

gradel build -Dquarkus.package.type=native

docker build -f src/main/docker/Dockerfile.native -t quarkus/demo .

docker run -i --rm -p 8080:8080 quarkus/demo

Cuando lo corrí la primera vez, me tiro error porque estoy usando Windows y me dijo que instale el generador de imágenes windows haciendo esto : 

gu install native-image

 

Creando la primera aplicación con Quarkus

Empecemos por el principio, necesitamos graalvm 11 o superior (en realidad cualquier Jdk 11 o superior pero yo voy a utilizar graalvm para sacar todo el jugo) , maven o gradle (yo voy a usar intellij que viene con gradle y listo) y un ide. 

Pueden usar maven o gradle para crear el proyecto o intellij (tambien) pero yo utilice la pagina https://code.quarkus.io/ y luego lo abrí con intellij. Pero eso lo hice porque quise, pueden hacerlo como quieran. 

Más allá de si eligieron maven o gradle o como hiciero para crear el proyecto, deberían tener esta dependencia : 

implementation 'io.quarkus:quarkus-resteasy'

Ahora veamos el código que genero, es un hola mundo común en un servicio REST : 

import javax.ws.rs.GET;

import javax.ws.rs.Path;

import javax.ws.rs.Produces;

import javax.ws.rs.core.MediaType;

@Path("/hello")

public class GreetingResource {

    @GET

    @Produces(MediaType.TEXT_PLAIN)

    public String hello() {

        return "Hello RESTEasy";

    }

}

Si ejecutamos esto con : 

gradle :quarkusDev 

Va a demorar un rato pero luego si vamos a http://localhost:8080/hello vemos : 

Hello RESTEasy

Y como primer acercamiento, bien, en proximos post vamos a seguir desarrollando este ejemplo. 

Programación poliglota con GraalVM

Una de las características de GraalVM es que podemos programar en diferentes lenguajes. Y esto es gracias a Truffle. 

Truffle es un framwork Java para construir implementaciones de lenguajes de programación como intérpretes para árboles de sintaxis abstractos auto-modificables. Al escribir un intérprete de lenguaje con Truffle, automáticamente usará el compilador GraalVM como un compilador jit (just in time) para el lenguaje. Al tener acceso a este framework, una aplicación Ruby, por ejemplo, puede ejecutarse en la misma JVM que una aplicación Java. Además, un lenguaje host basado en JVM y un lenguaje invitado pueden interactuar directamente entre sí y pasar datos de un lado a otro en el mismo espacio de memoria.

Con el fin de proporcionar valores políglotas en los lenguajes implementados con Truffle, se ha desarrollado el llamado protocolo de interoperabilidad políglota. Este protocolo de interoperabilidad consiste en un conjunto de mensajes estandarizados que cada lenguaje implementa y usa para valores políglotas. El protocolo permite a GraalVM admitir la interoperabilidad entre cualquier combinación de lenguajes sin que sea necesario que se conozcan entre sí. 

En próximos post, vamos a profundizar como ejecutar aplicaciones políglotas con graalvm. 

Dejo link: https://www.graalvm.org/reference-manual/polyglot-programming/

Spring + GraalVM = Spring Native

Micronaut y quarkus son frameworks similares a Spring pero con la ventaja de que son mucho más performantes. Estos frameworks utilizan la potencia de GraalVM para ser mucho más performante. Spring habia quedado un tanto desplazado en este nicho de mercado hasta ahora. 

Spring lanzo la primera versión de Spring Native, para convertir las aplicaciones Spring Boot existentes, escritas en Java o Kotlin, en imágenes nativas de GraalVM. Las imágenes nativas de GraalVM son pequeñas, optimizadas y se inician rápidamente. Las compensaciones, sin embargo, son tiempos de compilación más largos y menos optimizaciones de tiempo de ejecución en comparación con la JVM.

Trabajando con el equipo de GraalVM durante los últimos 18 meses, Spring Native actúa como un puente para garantizar que GraalVM comprenda el código Spring Boot tradicional.

Dejo link : https://spring.io/blog/2020/11/23/spring-native-for-graalvm-0-8-3-available-now

Que puedo hacer con GraalVM?

GraalVM es (en mi opinión) uno de los proyectos más interesantes de estos tiempos en el mundo java. 

Lo que pasa es que GraalVM es un proyecto paraguas y dentro tiene varios proyectos que permiten hacer diferentes cosas. Veamos que podemos hacer con este proyecto: 

1. Correr java más rápido. La JVM de GraalVM es más rápida que la jvm estandar.  

2. Low-footprint, fast-startup Java

3. Podemos escribir aplicaciones poliglotas en : JavaScript, Java, Ruby y R

4. Ejecutar las aplicaciones java de forma nativa

5. Utilizar herramientas que funcionan en todos los lenguajes

6. Código Java como biblioteca nativa

7. Polyglot en la base de datos, correr aplicaciones Java en la base de datos. 

8. Crear tu propio lenguaje. 

Como se puede ver hay varias cositas. Vamos a centrarnos en cada una en post posteriores. 

GraalVM 21.0 introduce una JVM escrita en Java

GraalVM es (en mi opinión) uno de los proyectos más interesantes de estos tiempos en el mundo java. 

La versión 21 introduce una JVM escrita en Java. Con esta versión, Java on Truffle, una JVM escrita en Java que utiliza el framework Truffle, proporciona una opción adicional para ejecutar aplicaciones Java.

Java on Truffle, con nombre en código Espresso, se puede instalar utilizando GraalVM Updater que es un administrador de paquetes que descarga e instala paquetes que no están incluidos en la distribución principal de GraalVM.

gu install espresso

Para ejecutar una aplicación Java usando Java en Truffle, la opción -truffle debe pasarse al comando java.

java -truffle -jar awesomeApp.jar

Java on Truffle es una JVM minificada que proporciona todos los componentes centrales de una JVM como el intérprete de bytes code, la interfaz nativa de Java (JNI) y el protocolo Java Debug Wire (JDWP). Implementa las API de la biblioteca Java Runtime Environment (libjvm.so) y reutiliza todos los JAR necesarios y las bibliotecas nativas de GraalVM. Y al igual que con una JVM tradicional, Java on Truffle admite la ejecución de otros lenguajes basados en JVM como Kotlin.

Dado que está implementado en Java y puede ejecutar Java, Java en Truffle es esencialmente Java autohospedado o Java en Java. Esto abre oportunidades interesantes para investigar e innovar la JVM, ya que permite a los desarrolladores de Java leer y comprender el código fuente de la JVM y mejorarlo.

Dejo link: 

https://www.graalvm.org/release-notes/21_0/

https://www.graalvm.org/reference-manual/java-on-truffle/

Por qué GraalVM?

Lo único malo que veo en GraslVM es el marketing que están llevando. Dado que GraalVM es un proyecto paraguas donde hay varios proyectos. Entre los que tenemos una maquina virtual más rápida, la capacidad de compilar nuestras aplicaciones de forma nativa o diferentes plataformas o ejecutar varios lenguajes. 

Lo que hace que cuando hablemos de GraalVM, estemos hablando de cosas diferentes, todo a la vez. 

GraalVM es un maquina virtual java de alto rendimiento que proporciona mejoras significativas en el rendimiento y la eficiencia de la aplicación, lo que es ideal para microservicios. Está diseñado para aplicaciones escritas en Java, JavaScript, lenguajes basados ​​en LLVM como C y C++, y otros lenguajes dinámicos. Elimina el aislamiento entre lenguajes de programación y habilita la interoperabilidad en un tiempo de ejecución compartido. Puede ejecutarse de forma independiente o en el contexto de OpenJDK, Node.js u Oracle Database.

Para las aplicaciones Java existentes, GraalVM puede proporcionar beneficios al ejecutarlas más rápido, brindar extensibilidad a través de lenguajes de secuencias de comandos o crear imágenes nativas compiladas.

GraalVM se puede ejecutar en el contexto de OpenJDK para hacer que las aplicaciones Java se ejecuten más rápido con una nueva tecnología de compilación jit. GraalVM se hace cargo de la compilación del byte code de Java en código de máquina. En particular, para otros lenguajes basados ​​en JVM como Scala, esta configuración puede lograr beneficios, como por ejemplo, lo experimentó Twitter al ejecutar GraalVM en producción.

GraalVM permite ejecutar JavaScript, R, Python, Ruby, LLVM IR y Web Assembly en el contexto de aplicaciones Java. Ofrece la capacidad de exponer las estructuras de datos de Java a esos lenguajes con filtros de acceso de host detallados. La integración es independiente del lenguaje, es decir, una integración para JavaScript también se puede utilizar en un punto posterior para ejecutar cualquier otro lenguaje basado en GraalVM. Los mecanismos de proxy permiten simular objetos dinámicos de estructuras de datos Java y exponerlos a los scripts integrados. 

La ejecución de su aplicación dentro de una máquina virtual Java conlleva costos de inicio y de espacio. GraalVM tiene una función para crear imágenes nativas para aplicaciones existentes basadas en JVM. El proceso de generación de imágenes emplea análisis estático para encontrar cualquier código accesible desde el método principal de Java y luego realiza una compilación completa con anticipación (AOT). El binario nativo resultante contiene todo el programa en forma de código máquina para su ejecución inmediata. Se puede vincular con otros programas nativos y, opcionalmente, puede incluir el compilador GraalVM para soporte de compilación complementaria Just-In-Time (JIT) para ejecutar cualquier lenguaje basado en GraalVM con alto rendimiento. Para obtener un rendimiento adicional, se pueden crear imágenes nativas con optimizaciones guiadas por perfiles recopiladas en una ejecución anterior de la aplicación. Vea un ejemplo de cómo crear imágenes nativas aquí.

GraalVM puede ejecutarse en el contexto de Node.js reemplazando V8 con GraalVM para ejecutar JavaScript. Los principales beneficios de hacerlo es habilitar aplicaciones políglotas (por ejemplo, usar bibliotecas Java, R o Python), ejecutar Node.js con configuraciones de montón grandes y recolectores de basura de Java, o usar la interoperabilidad de GraalVM para definir estructuras de datos en C / C ++ y utilícelos desde JavaScript.

GraalVM permite el uso de bibliotecas Java existentes o frameworks Java (como Spark o Flink) directamente desde Node.js. Además, se puede usar, por ejemplo, R o Python para ciencia de datos o trazar directamente desde una aplicación JavaScript.

El motor de JavaScript V8 incluido en la distribución estándar de Node.js está optimizado para las configuraciones del navegador y diseñado para funcionar de manera efectiva en escenarios de almacenamiento pequeño. Habilitamos la ejecución de Node.js con la gestión de montón de la JVM, lo que abre la posibilidad de configuraciones de montón grandes y configuraciones adecuadas de recolección de basura. El tamaño máximo de pila configurable es de 32 Gb con punteros comprimidos de 32 bits, y se admiten terabytes de pila en la configuración de puntero de 64 bits.

GraalVM permite una combinación eficiente de código nativo (por ejemplo, escrito en C / C ++) y JavaScript. Se puede acceder directamente a las estructuras de datos nativas y el compilador puede integrarse a través de cualquier límite. Esto puede ser beneficioso en un escenario donde las estructuras de datos eficientes se administran y asignan en C mientras que otras partes de la aplicación están escritas en Node.js. 

Ruby, R, Python, WebAssembly son experimentales en el ecosistema GraalVM y no se recomiendan para uso de producción en este momento, pero estamos trabajando activamente en la estabilidad y el soporte para todos los módulos para esos lenguajes. En este momento, podemos ejecutar aplicaciones más simples de Ruby, R y Python, pero no tenemos la misma compatibilidad total que proporcionamos para las aplicaciones Java y Node.js. WebAssembly actualmente implementa la especificación WebAssembly MVP (producto mínimo viable) y es el lenguaje más reciente en el entorno GraalVM.

Además de los beneficios estándar de GraalVM, como la interoperabilidad de idiomas (por ejemplo, usar Java o JavaScript desde esas aplicaciones), GraalVM puede lograr altas velocidades de 10 veces o más para esos idiomas. Nos complace ayudarlo a hacer que las aplicaciones Ruby y R existentes funcionen con GraalVM, pero todavía no podemos garantizar la compatibilidad inmediata para estos idiomas.

GraalVM está diseñado para integrarse y se puede ejecutar en bases de datos. El prototipo de Oracle Database Multilingual Engine (MLE) está disponible. Permite a los usuarios de Oracle Database ejecutar JavaScript, utilizando browserify para ejecutar módulos Node.js y escribir extensiones en Python.

GraalVM Native Image, actualmente disponible como tecnología de pioneros, funciona con muchos marcos de microservicios Java diferentes. Varios proyectos ya han aceptado esta tecnología como plataforma para sus aplicaciones: Quarkus, Micronaut, Helidon. Para estos marcos, las imágenes nativas de GraalVM reducen significativamente los requisitos de memoria en tiempo de ejecución en comparación con la ejecución en HotSpot. Creemos que la tecnología GraalVM Native Image puede convertirse en la mejor manera de implementar aplicaciones nativas en la nube.

Fomentamos el desarrollo de incrustaciones de GraalVM similares a nuestras propias integraciones en Oracle Database, OpenJDK o Node.js. Junto con socios de colaboración de investigación, ya exploramos ideas de incrustación en Spark o Flink. Encuentre una descripción sobre cómo incrustar GraalVM en su aplicación nativa o basada en JVM existente aquí.

GraalVM es un ecosistema abierto e invitamos a los sistemas de terceros a participar conectando sus propios lenguajes de programación, herramientas o plataformas.

El marco de implementación de Truffle Language permite ejecutar lenguajes de programación de manera eficiente en GraalVM. Simplifica la implementación del lenguaje al derivar automáticamente código de alto rendimiento de los intérpretes. Puede encontrar detalles sobre el enfoque en este artículo de investigación.

Implementar su propio lenguaje usando GraalVM no solo le dará un alto rendimiento. Más importante aún, permite que su lenguaje se conecte con las herramientas enriquecidas proporcionadas por el ecosistema GraalVM. Además, permite que su lenguaje se ejecute en el contexto de cualquier incrustación de GraalVM.

Se Desarrollao un lenguaje de demostración llamado "SimpleLanguage" para mostrar el uso del marco de implementación del lenguaje de GraalVM. 

GraalVM proporciona un marco para crear herramientas independientes del lenguaje como depuradores, perfiladores u otras instrumentaciones. GraalVM proporciona una forma estandarizada de expresar y ejecutar código de programa que permite la investigación en varios idiomas y el desarrollo de herramientas que se desarrollan una vez y luego se pueden aplicar a cualquier idioma.

Dejo link: 

https://www.graalvm.org/docs/why-graal/

The Truffle Language Implementation Framework

Graal es un super proyecto, que en su paraguas contiene muchos subproyectos. Tal vez el más famoso es pasar a nativa una aplicación java con las imagenes, que se hizo famoso por mejorar mucho la performance de aplicaciones java. 

Pero no voy a hablar de eso ahora, si no de otro subproyecto que permite implementar cualquier lenguaje a en la maquina virtual de graal. Truffle representa un avance significativo en la tecnología de implementación de lenguaje de programación dinámicos en la maquina virtual Graal.

Para hacerla corta Truffle nos permite implementar de forma sencilla un lenguaje dinámico en la maquina virtual GraalVM, con lo cual podemos llevar un programa escrito en un lenguaje dinámico a una imagen nativa. Haciendo que sea super rapido (comparado con su versión no nativa). Y a la vez nos brinda herramientas comunes para debugear diferentes lenguajes. 

Además provee un lenguaje simple como ejemplo. SimpleLanguage es un lenguaje de demostración creado con la API Truffle. El proyecto SimpleLanguage proporciona un escaparate sobre cómo usar las API de Truffle para escribir su propio Lenguaje. Su objetivo es utilizar la mayoría de las funciones del marco Truffle disponibles y documenta su uso ampliamente con la documentación fuente en línea.

Truffle es desarrollado y mantenido por Oracle Labs y el Institute for System Software de la Universidad Johannes Kepler de Linz.

Dejo link: 

https://github.com/oracle/graal/tree/master/truffle

Quarkus

No dejo de escuchar de Quarkus, pero que es quarkus? 

Quarkus es un framework Java integral y nativo de Kubernetes que se creó para las compilaciones nativas y las máquinas virtuales Java (JVM), el cual permite optimizar Java, especialmente para los contenedores y convertirla en una plataforma efectiva para entornos sin servidor, de nube y de Kubernetes.

Quarkus se diseñó para integrarse con Eclipse MicroProfile, Apache Kafka, RESTEasy (JAX-RS), Hibernate ORM (JPA), Spring, Infinispan, Camel y muchos más. 

La solución de inyección de dependencias de Quarkus se basa en CDI (inyección de dependencias y contextos) e incluye un marco de extensión para ampliar las funciones y configurar, iniciar e integrar un marco en las aplicaciones.Dado que agregar una extensión es tan sencillo como incorporar una dependencia, puede optar por esa opción o utilizar las herramientas de Quarkus.

Además, proporciona la información correcta a GraalVM (una máquina virtual universal para ejecutar aplicaciones escritas con varios lenguajes, incluidos Java y JavaScript) para la compilación nativa de las aplicaciones.

Quarkus se diseñó para que fuera fácil de utilizar desde el principio, y cuenta con características que funcionan correctamente con poca o ninguna configuración.

Los desarrolladores pueden elegir los frameworks de Java que deseen para sus aplicaciones, los cuales pueden ejecutarse en modo JVM o compilarse y ejecutarse en el modo original. 

Diseñado para que los desarrolladores lo disfruten, Quarkus también incluye las siguientes funciones:

• Programación en vivo para que los desarrolladores puedan verificar de inmediato el efecto de los cambios en el código y solucionarlos rápidamente
• Programación imperativa y reactiva unificada con un bus de eventos integrado y gestionado
• Configuración unificada
• Creación sencilla de archivos ejecutables nativos

Independientemente de que una aplicación se aloje en una nube pública o en un clúster de Kubernetes alojado internamente, las características como el inicio rápido y el poco consumo de memoria son importantes para mantener bajos los costos generales del host.

Quarkus se diseñó en torno a una filosofía que prioriza los contenedores, lo que significa que se encuentra optimizado para disminuir el uso de la memoria y acelerar los tiempos de inicio, a través de lo siguiente:

• Respaldo de primer nivel para GraalVM y SubstrateVM
• Procesamiento de metadatos en tiempo de compilación
• Reducción en el uso del proceso de reflexión
• Inicio previo de imágenes nativas

Por lo tanto, Quarkus compila aplicaciones que consumen un décimo de la memoria en comparación con Java tradicional, y ofrece tiempos de inicio hasta 300 veces más rápidos, lo cual reduce significativamente el costo de los recursos de la nube.

Quarkus está diseñado para combinar a la perfección la programación imperativa conocida con la reactiva sin bloqueos durante el desarrollo de aplicaciones. 

Esta característica resulta útil tanto para los desarrolladores de Java que suelen trabajar con el modelo imperativo y no desean cambiar las cosas, como para aquellos que trabajan con un enfoque reactivo/nativo de la nube. 

El modelo de desarrollo de Quarkus se adapta a cualquier aplicación en proceso de desarrollo.

Además, es una solución efectiva para ejecutar Java en este mundo nuevo de la arquitectura sin servidor, los microservicios, los contenedores, Kubernetes, la función como servicio (FaaS) y la nube, ya que se creó teniendo en cuenta todos estos elementos. 

Dejo link : https://quarkus.io/

GraalVM 19.3 soporta a JDK 11

GraalVM, una máquina virtual políglota que proporciona un tiempo de ejecución compartido para ejecutar aplicaciones escritas en múltiples lenguajes como Java, C, Python y JavaScript, ha lanzado la versión 19.3 con soporte para JDK 11. Las versiones anteriores de GraalVM se basaban en JDK 8.

Las numerosas funciones de lenguaje y mejoras de plataforma como cadenas compactas, inferencia de tipo variable, Java Platform Module System (JPMS) y cliente HTTP, que se entregaron entre la versión Java 9 y la versión Java 11 ahora pueden ser utilizadas por aplicaciones JVM creadas en GraalVM.

Por ejemplo, el siguiente fragmento muestra cómo se puede construir e invocar una solicitud simple a una API REST de bitcoin utilizando el nuevo cliente HTTP Java 11:

public class BPI {
  public static void main(String... args) {
    var request = HttpRequest
        .newBuilder()
        .uri(URI.create("https://api.coindesk.com/v1/bpi/currentprice.json"))
        .GET()
        .build();

    var response = HttpClient
        .newHttpClient()
        .send(request, HttpResponse.BodyHandlers.ofInputStream());

    var json = Json
        .createReader(response.body())
        .readObject()
        .getJsonObject("bpi");
    …
    System.out.printf("Current Bitcoin Price: $%s %s", price, indicator);
  }
}

Con JAVA_HOME y PATH apuntando a una instalación de GraalVM, las clases basadas en Java 11 como la clase de ejemplo anterior se pueden compilar utilizando el compilador javac o una herramienta de compilación como Maven.

La utilidad de generación de imágenes nativas de GraalVM también se ha actualizado para admitir Java 11 como una característica de tecnología. Una imagen nativa es un código de bytes Java compilado con anticipación empaquetado como un ejecutable independiente. La imagen nativa generalmente logra un tiempo de inicio más rápido. La imagen nativa no es compatible con Java Platform Module System y no tiene introspección de módulo en tiempo de ejecución de imagen. La utilidad de imagen nativa es un paquete opcional que se puede instalar usando el Actualizador GraalVM, gu. gu es un administrador de paquetes que descarga e instala paquetes no incluidos en la distribución principal de GraalVM.

Para aquellos que usan Maven como herramienta de compilación, se proporciona un complemento Maven para ayudar en el proceso de generación de imágenes.

También tenga en cuenta que dado que el recolector de basura Garbage-First (G1) es el recolector de basura predeterminado en Java 11, se debe tener cuidado al migrar aplicaciones sensibles al rendimiento de GraalVM basado en JDK 8 a GraalVM basado en JDK 11.

Además del soporte para JDK 11, esta primera versión de soporte a largo plazo (LTS) de GraalVM proporciona mejoras en la generación de imágenes nativas, el compilador GraalVM, herramientas como cobertura de código y GraalVM VisualVM junto con actualizaciones en tiempo de ejecución de los lenguajes NodeJS, Python y R.

Dejo link: https://www.graalvm.org/

Apache NetBeans 11.1 fue liberado

La versión 11.1 de Apache NetBeans fue liberado, la primera versión que se lanzará después de convertirse en un proyecto de top level de Apache.

La nueva versión cuenta con soporte para la sintaxis Java 11 y 12, así como una estrecha integración con los proyectos Jakarte EE / Java EE 8 a través de los servidores de aplicaciones Payara y Glassfish. Los proyectos se pueden crear directamente a través de Maven y Gradle, utilizando el nuevo arquetipo webapp-javaee8. Esto permite a los desarrolladores trabajar y depurar aplicaciones completamente a través de los sistemas de compilación nativos, en lugar de un archivo de proyecto separado que emula al sistema de compilación.

Los desarrolladores de aplicaciones móviles o de escritorio pueden aprovechar la contribución de Gluon de las muestras de OpenJFX en NetBeans. Combinado con la comunidad GraalVM, OpenJFX permite a los desarrolladores codificar en Java y crear ejecutables nativos que se ejecutan directamente en dispositivos móviles. Usando NetBeans, los desarrolladores pueden crear y depurar estas aplicaciones antes de la implementación dentro de las tiendas de aplicaciones móviles. NetBeans también contribuyó a la creación de GraalVM este permite la visualización de gráficos de dependencia de programas, basados ​​en la plataforma NetBeans.

NetBeans tambien ofrece soporte para el desarrollo JavaScript en el lado del cliente o servidor, así como soporte nativo para aplicaciones PHP 7.4.

Y ya podemos bajarlo dejo link :
https://netbeans.apache.org/
http://netbeans.apache.org/download/nb111/index.html