Entendiendo el flujo MuleSoft

En la anterior entrega dijimos que MuleSoft es una plataforma de integración que te permite conectar aplicaciones, datos y APIs de manera centralizada.

Continuaremos hablando de esta poderosa plataforma.

¿Cómo funciona el flujo MuleSoft?

MuleSoft recomienda tres capas o componentes (conocidas como API-led architecture):

• Experience API. 
• Process API. 
• System API.

Miremos este diagrama que lo describe mejor:

                  CLIENTES
                     │
                     ▼
        ┌─────────────────────────┐
        │ Experience API          │
        │ Web / Mobile / Partner  │
        └──────────┬──────────────┘
                   │
                   ▼
        ┌─────────────────────────┐
        │ Process API             │
        │ Orquestación negocio    │
        └──────────┬──────────────┘
                   │
         ┌─────────┴─────────┐
         ▼                   ▼
┌────────────────┐  ┌────────────────┐
│ System API     │  │ System API     │
│ Spring Boot    │  │ SAP / Oracle   │
└────────┬───────┘  └────────────────┘
         │
         ▼
   ┌──────────┐
   │ Database │
   └──────────┘

Empecemos con las Experience API.

¿En qué consiste la Experience API?

Las Experience APIs están diseñadas para adaptar los datos a experiencias de usuario específicas (ya sea una aplicación móvil, una interfaz web o un sistema de terceros) sin exponer la complejidad de los sistemas de backend.

Agregan y filtran datos de las API de proceso (Process API) o las API del sistema (System API) para satisfacer las necesidades de un cliente en particular.

¿Por qué utilizar Experience APIs?

• Entrega de datos personalizada: Las Experience APIs entregan exactamente lo que el frontend o la aplicación necesita, reduciendo el tamaño de la carga útil y mejorando el rendimiento. 
• Desacoplamiento entre frontend y backend: Permiten que los equipos de frontend trabajen de forma independiente respecto a los sistemas de backend, facilitando ciclos de desarrollo e iteración más rápidos. 
• Reutilización y agilidad: Múltiples interfaces de frontend (móvil, web, etc.) pueden utilizar el mismo backend, pero consumiendo datos a través de distintas Experience APIs adaptadas a sus necesidades específicas.

Ahora continuaremos con las Process API.

¿En qué consiste la Process API?

Las Process API orquestan y procesan datos a través de múltiples System API.

Se encargan de combinar y orquestar datos provenientes de múltiples sistemas para llevar a cabo procesos de negocio específicos. No interactúan directamente con bases de datos o sistemas; en su lugar, invocan a otras API (generalmente las System API) para recopilar, procesar y transformar los datos antes de exponerlos a la Experience API u otros servicios.

Sus principales funciones son:

• La orquestación de datos provenientes de múltiples fuentes. 
• La aplicación de lógica de negocio o transformaciones a los datos. 
• La combinación de respuestas de múltiples API de sistema.
• Mejorar de la reutilización mediante el desacoplamiento de sistemas e interfaces de usuario.

Ahora continuaremos con las System API.

¿En qué consiste la System API?

Las System API están diseñadas para interactuar con los sistemas centrales de registro, como bases de datos, sistemas ERP y aplicaciones heredadas. Estas API proporcionan una interfaz estandarizada para acceder y gestionar datos, garantizando la coherencia y la fiabilidad en diversas aplicaciones.

Sus funciones principales son:

• Integración con los sistemas centrales: Las System API se conectan a los sistemas de backend para recuperar y manipular datos. 
• Coherencia de los datos: Garantizan un acceso y una gestión uniformes de los datos en diferentes aplicaciones. 
• Estandarización: Las System API ofrecen una interfaz coherente para acceder a los datos del sistema, lo que reduce la complejidad para los desarrolladores. 
• Seguridad: Proporcionan acceso seguro a datos confidenciales, cumpliendo con las políticas de cumplimiento y gobernanza.

Resumiendo

• Experience API: Exponen datos adaptados a aplicaciones o experiencias de usuario específicas. Agregan y filtran datos provenientes de las Process API  o de las System API para satisfacer las necesidades de un cliente en particular. 
• System API: Se conectan directamente a sistemas subyacentes, como bases de datos o aplicaciones SaaS. 
• Process API: Orquestan y procesan datos a través de múltiples API de sistema.

En el entorno de MuleSoft, comprender las diferencias entre las API de sistema, las API de proceso y las API de experiencia es fundamental para una integración y un desarrollo de aplicaciones eficaces.

Cada tipo de API cumple una función específica dentro de la arquitectura, garantizando una conectividad fluida, procesos optimizados y una mejor experiencia de usuario.

Continuaremos más sobre esto en próximas entregas.

Enlaces:

https://medium.com/@aleksej.gudkov/mulesoft-experience-api-example-a-step-by-step-guide-50c428cdc0ca
https://codemonkeyjunior.blogspot.com/2026/07/como-funcionan-los-flujos-en-mulesoft.html
https://codemonkeyjunior.blogspot.com/2026/07/como-funcionan-los-flujos-en-mulesoft.html
https://medium.com/@aleksej.gudkov/mulesoft-process-api-example-1c20d1c05a88
https://apix-drive.com/en/blog/other/mulesoft-system-api-vs-process-api-vs-experience-api

¿Qué podemos hacer con Grain?

En una entrega anterior vimos un poco del lenguaje Grain.

Grain es un lenguaje de programación funcional, moderno y de código abierto, diseñado principalmente para compilarse a WebAssembly (Wasm), lo que le permite funcionar eficientemente tanto en navegadores web como en servidores.

Grain en un vistazo

Su objetivo es hacer accesibles las características avanzadas de los lenguajes funcionales, siendo fácil de aprender, fuertemente tipado y flexible.

Definiendo variables

Tipos de datos en Grain:

• Number, para datos numéricos. 
• Bool, para datos booleanos (true, false) 
• Char, para caracteres. 
• String, para cadenas de caracteres. 

Crearemos un programa llamado ``variables.gr``:

module Variables

print("\t [  Variables en Grain  ] \n")

Es importante que el módulo tenga el mismo nombre del programa.

Ahora definamos algunas variables:

module Variables

// Variables
let numeroInt = 65
let valorBoolean = true
let otroInt:Number = numeroInt + 32
let division = numeroInt / 4.0
let otroBool: Bool = false
let cadenaString: String = "Bienvenido a Grain!" and someChar: Char = '@'
let escritor = ("Thomas Muller", 47, "El cubo blanco.")
let (nombre, edad, libro) = escritor
let resultado = if (otroBool) "Pista blanca." else "Pista azul."
let valorImprime: Void = print("Esto se vera en la pantalla.")

print("\t [  Variables en Grain  ] \n")

¿Qué podemos notar?

• Usamos la palabra ``let`` para definir variables. 
• Podemos especificar el tipo o también lo podemos omitir. 
• Usamos tipos Number, Char, Bool, String. 
• Grain es un lenguaje funcional, donde las variables son inmutables.

Imprimiendo las variables

Ahora vamos a imprimir las variables:

module Variables

// ...

print("\t [  Variables en Grain  ] \n")
print(cadenaString)
print(numeroInt)

if (valorBoolean){
  print(valorBoolean)
}

if(false){
  print("A")
}else if(54 > 100){
  print("B")
} else{
  print("C")
}

if(otroBool){
  print("Esto no se vera.")
}

print(otroInt)
print(division)
print((45 * 43 - 56 / 2))
print(escritor)
print(nombre)
print(edad)
print(libro)
print(resultado) 

Aserciones

Una aserción (assert) es una verificación lógica en el código que comprueba si una condición es verdadera; si resulta falsa, detiene el programa o lanza un error.

Grain nos permite usar instrucciones assert. Agregemoslas:

module Variables

// ...

print("\t [  Variables en Grain  ] \n")

// ...
assert true == (!false)
assert (34 < 100) == (43  > 0)
assert valorImprime == void

Todas son verdaderas; en caso de no ser así el programa fallaría.

Ahora el programa completo:

module Variables


let numeroInt = 65
let valorBoolean = true
let otroInt:Number = numeroInt + 32
let division = numeroInt / 4.0
let otroBool: Bool = false
let cadenaString: String = "Bienvenido a Grain!" and someChar: Char = '@'
let escritor = ("Thomas Muller", 47, "El cubo blanco.")
let (nombre, edad, libro) = escritor
let resultado = if (otroBool) "Pista blanca." else "Pista azul."
let valorImprime: Void = print("Esto se vera en la pantalla.")

print("\t [  Variables en Grain  ] \n")
print(cadenaString)
print(numeroInt)

if (valorBoolean){
  print(valorBoolean)
}

if(false){
  print("A")
}else if(54 > 100){
  print("B")
} else{
  print("C")
}

if(otroBool){
  print("Esto no se vera.")
}

print(otroInt)
print(division)
print((45 * 43 - 56 / 2))
print(escritor)
print(nombre)
print(edad)
print(libro)
print(resultado) 

assert true == (!false)
assert (34 < 100) == (43  > 0)
assert valorImprime == void

Ejecutemos el programa:

$ grain variables.gr

Salida:

Esto se vera en la pantalla.
         [  Variables en Grain  ]

Bienvenido a Grain!
65
true
C
97
16.25
1907
("Thomas Muller", 47, "El cubo blanco.")
Thomas Muller
47
El cubo blanco.
Pista azul.

Al ejecutar con este comando, el programa generará otros archivos (variables.gro y variables.wasm); el que nos interesa es el código WASM, pues el que se ejecutará en el navegador y otros entornos que lo soporten.

Grain y WebAssembly

WebAssembly es un formato de código binario portable y un formato de texto correspondiente, así como interfaces de software para facilitar la comunicación entre dichos programas y su entorno anfitrión. Grain nos permite generar ese código binario.

Todo hasta aquí va bien, pero no hemos respondido la pregunta:

¿Qué podemos hacer con Grain?

Podemos decir que:

• Se puede crear aplicaciones WebAssembly para ejecutarse con gran eficiencia dentro de los navegadores o del lado del servidor. 
• Desarrollar servicios y microservicios sin servidor (Serverless).

Seguiremos hablando de este lenguaje en próximas entregas.

Enlaces:

https://grain-lang.org/
https://codemonkeyjunior.blogspot.com/2015/03/aserciones.html
WASM: ¿Qué es?¿Por qué es importante? (Youtube)

Lenguajes que no todos usan pero existe un mercado importante

El mundo de la informática y programación siempre está en movimiento. Todo cambia todo el tiempo.

Excel se ha convertido oficialmente en un lenguaje de programación. Las herramientas de I.A. cada vez son más usadas en las empresas (que antes rehuían de ellas, y hasta las prohibían). El programador no solo debe tener un repertorio de habilidades y conocimientos considerable ahora es indispensable saber usar éstas herramientas.  

Saber Java, PHP, Javascript, Spring Boot ... Claude Code, Github Copilot, etc. es cada día más necesario, casi obligatorio. ¿Por qué pasa con esos lenguajes raros que aparecen en algunas soicitudes? Y no, no estamos hablando de lenguajes como Rust, Go, Ballerina o hasta Erlang y Haskell. Estamos hablando de lenguajes o plataformas de desarrollo especializados en ciertas cosas como las finanzas, la estadística, el tratamiento de datos, etc.

Lenguajes o plataformas que deberíamos conocer y casi nadie sabe

Lenguajes que casi nadie conoce como:

• Apex.  
• esProc SPL.  
• OpenEdge (Progress) ABL.
• SAS.

Recapitulando:

Apex, es un lenguaje de programación orientado a objetos desarrollado por Salesforce para el desarrollo de aplicaciones en su plataforma de gestión de relaciones con clientes (CRM). Orientado a Objetos, fuertemente tipado, con una sintaxis similar a la de Java y C#. Integrado estrechamente con la plataforma Salesforce.

esProc SPL, es un lenguaje de procesamiento y cálculo de datos. Diseñado para el procesamiento avanzado de datos y se destaca en el manejo eficiente de conjuntos de datos masivos.

OpenEdge (Progress) ABL, un lenguaje de programación vinculado al entorno Progress OpenEdge, su base de datos y las utilidades que lo rodean. También ofrece herramientas esenciales para el desarrollo de aplicaciones, lo que le permite tener fácil acceso a todos los recursos de su aplicación.

SAS, es una plataforma software y un lenguaje de programación opera principalmente sobre tablas de datos. Influido por PL/1, un lenguaje de programación de propósito general adecuado para programación comercial, científica, no científica y de sistemas. Puede usar consultas SQL para la manipulación de los datos de las tablas.

Muchas preguntas tendrá el programador que no sabía de su existencia:

• ¿Para qué usarlos? 
• ¿En qué tipos de proyecto se ocupan? 
• ¿Son libres de uso o tienen licencia? 
• ¿Dónde y cómo los aprendo?
• ¿Qué tan difícil es la curva de aprendizaje?

Observemos la siguiente tabla informativa:

Pregunta / Cuestión	Apex (Salesforce)	esProc SPL	OpenEdge (Progress) ABL	SAS
¿Para qué usarlos?	Automatizar procesos de negocio complejos, crear lógica de backend, desencadenadores (triggers) e integraciones web dentro del ecosistema de Salesforce.	Realizar cálculos complejos, transformaciones de datos masivos y procesamiento analítico de alto rendimiento como alternativa más eficiente a SQL/Python en escenarios de Big Data.	Desarrollar aplicaciones empresariales orientadas a negocios (ERP, CRM, gestión de inventarios) conectadas directamente a su base de datos relacional nativa.	Realizar análisis estadístico avanzado, minería de datos, inteligencia de negocios (BI), modelado predictivo y gestión de tablas de datos a gran escala.
¿En qué tipos de proyecto se ocupan?	Proyectos de personalización de CRM, plataformas de ventas, atención al cliente, portales para usuarios y software SaaS sobre la plataforma Salesforce.	Módulos de procesamiento de datos en tiempo real, data warehouses, proyectos de migración de datos y microservicios analíticos de alto rendimiento.	Sistemas transaccionales (OLTP), software de gestión de recursos empresariales (ERP), sistemas bancarios, de manufactura y distribución.	Proyectos de analítica financiera, investigación clínica/farmacéutica, evaluación de riesgos crediticios y estudios estadísticos gubernamentales o académicos.
¿Son libres de uso o tienen licencia?	Licencia comercial (Propietario): El lenguaje se ejecuta en la nube de Salesforce. Requiere suscripciones a la plataforma (aunque existen cuentas de desarrollador gratuitas para pruebas).	Código abierto / Comercial: Cuenta con una versión de código abierto (Open Source / Community) de libre uso, además de ediciones comerciales con soporte empresarial.	Licencia comercial (Propietario): Requiere licencias de software de Progress Software tanto para el entorno de desarrollo como para la ejecución/base de datos.	Licencia comercial (Propietario): Es una plataforma cerrada de alto costo empresarial. Cuenta con SAS OnDemand for Academics (versión gratuita restringida para aprendizaje/docencia).
¿Dónde y cómo los aprendo?	Plataforma oficial: Salesforce Trailhead (gratuito e interactivo). Recursos: Documentación de Salesforce Developers, cursos en Udemy, Pluralsight y certificación oficial de Salesforce.	Plataforma oficial: Sitio web de Raqsoft / esProc y su repositorio en GitHub. Recursos: Documentación oficial, tutoriales en su sitio web, artículos de comparación con SQL y ejemplos en su comunidad.	Plataforma oficial: Progress Education Community y Progress Information Hub. Recursos: Cursos en la plataforma de Progress, documentación técnica de OpenEdge ABL y comunidades de desarrolladores Progress.	Plataforma oficial: SAS Skill Builder y SAS Learning Hub. Recursos: Cursos gratuitos con SAS OnDemand, certificaciones oficiales de SAS, tutoriales en Coursera y documentación técnica de SAS.
¿Qué tan difícil es la curva de aprendizaje?	Moderada: Si ya conoces Java o C#, la sintaxis te resultará muy familiar. La mayor dificultad no es el lenguaje en sí, sino entender los límites de recursos de la plataforma (Governor Limits) y la arquitectura de Salesforce.	Moderada a Alta: Utiliza un enfoque de programación basado en cuadrículas/tablas y un paradigma de datos diferente al de SQL tradicional o bucles convencionales, lo que requiere cambiar la forma de pensar el flujo de datos.	Baja a Moderada: Tiene una sintaxis en inglés muy conversacional y orientada a eventos/negocio. Diseñado para interactuar con bases de datos de forma muy sencilla, aunque su ecosistema propietario tiene sus particularidades.	Moderada: Su sintaxis es procedural y particular (basada en pasos DATA y pasos PROC). Si conoces SQL la manipulación de datos te resultará accesible, pero dominar los procedimientos estadísticos avanzados requiere una base matemática sólida.

Prácticamente todos son de licencia. Algo que el programador promedio no lo verá con buenos ojos. Salvo que el lugar donde los programadores se le dote de una licencia se ve difícil que uno desenvolse una cantidad considerable para hacerse con una para poder empezar a aprenderlo y usarlo.

Apex, esProc SPL, OpenEdge ABL, SAS frente a los lenguajes habituales

1. Frente a Java, C# y Kotlin:

• Apex es esencialmente un derivado estilizado de Java/C# reducido para correr en la nube de Salesforce. 
• Kotlin superpone expresividad moderna y paradigma funcional sobre la JVM, mientras que OpenEdge ABL y Apex priorizan la simplicidad de acceso a datos o reglas de negocio sobre la modernidad funcional del lenguaje.

2. Frente a Python, R y SQL (El mundo de los Datos):

• SAS reinó en la analítica corporativa durante décadas, pero Python y R han dominado el mercado moderno debido a su ecosistema abierto (Open Source), librerías de Machine Learning y versatilidad general. 
• esProc SPL busca solucionar las limitaciones sintácticas de SQL y el consumo de memoria de Python al procesar datos estructurados en lote.

3. Frente a JavaScript y PHP (Desarrollo Web y Prototipado):

• JavaScript y PHP son flexibles y dominan la web de propósito general. Por el contrario, Apex y OpenEdge ABL están empaquetados para conectarse directamente a entornos de datos sin necesidad de configurar frameworks de backend desde cero.

4. Frente a Rust, Go y Haskell (Rendimiento, Concurrencia y Rigor):

• Rust y Go se enfocan en concurrencia extrema, rendimiento a nivel de sistema y bajo consumo de recursos (microservicios e infraestructura). Ninguno de los 4 lenguajes especializados busca competir en este terreno. 
• Haskell empuja la pureza funcional y la verificación matemática del código. En contraste, lenguajes como SAS o esProc SPL priorizan un modelo declarativo/procedural directo enfocado exclusivamente en transformar tablas y series de datos de negocio.

¿Qué lenguaje de estos 4 es el más recomendado?

Apex es el más recomendado. Su sintaxis es prácticamente idéntica a Java(orientación a objetos, tipos de datos y estructuras). Además hay una enorme demanda global y local de desarrolladores Salesforce ("Salesforce Developers"), con sueldos competitivos.

Quien este familiarizado con el desarrollo de APIs con Spring Boot lo encontará fácil o al menos podrá adaptarse mejor con respecto a los 3 restatntes.

esProc SPL, es excelente para procesamiento analítico de datos masivos como alternativa a SQL/Python, pero no está diseñado para construir arquitectura de microservicios o APIs empresariales. Un punto en contra. Poco recomendado.

SAS, es dominado por analistas de datos, estadísticos y científicos de datos. Se aleja del perfil de desarrollo de software/APIs tradicional y usa un paradigma procedural (pasos DATA y PROC). Un punto en contra. Poco recomendado.

OpenEdge ABL, es un lenguaje propietario enfocado en mantenimiento de sistemas legacy o ERPs específicos. La curva de oportunidad laboral es mucho más reducida frente al ecosistema moderno de APIs. Nada recomendado.

En definitiva, Apex es la mejor opción.

Continuaremos sobre estos temas y otras cosas sobre programación.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/06/sas-un-lenguaje-de-programacion-para.html
https://codemonkeyjunior.blogspot.com/2024/06/apex-un-lenguaje-de-programacion.html
https://codemonkeyjunior.blogspot.com/2024/03/openedge-abl-como-definir-variables-y.html
https://codemonkeyjunior.blogspot.com/2024/12/mas-sobre-esproc-spl-un-lenguaje.html

Jai un lenguaje de programación inspirado en C++

Hoy hablaremos de un nuevo lenguaje de programación llamado Jai.

Se trata de un lenguaje de programación que está desarrollando Jonathan Blow. El objetivo declarado del lenguaje es superar a C++ en el ámbito de la programación de videojuegos; sin embargo, en realidad se trata de una alternativa de propósito general a C++ con las siguientes metas:

• Alto rendimiento.
• Disfrute al programar.
• Simplicidad. 
• Baja fricción. 
• Diseñado para buenos programadores (sic).

Para quienes han programado en C sabrán que su descendiente directo, C++, es considerado más difícil de aprender y mucho más complejo de usar en proyectos reales.

Con C, el programador:

• Debe cuidar las variables que usará. Un tipo int no puede tener valores que no sean números entero, etc. 
• Deberá cuidar el uso de memoria, lenguajes como Java o Rust (más moderno) ayudan al programador con esto. 
• Tener un mejor control de sus estructuras de datos. 
• Saber cómo y cuándo usar punteros para agilizar la programación, sí para eso y más se usan.

Con C++, deberás ser mucho más cuidadoso, aún más. Es más complejo y relativamente más seguro.

Jai se une a una lista de lenguajes de programación que afirman ser el sucesor verdadero de C++, y esa lista crece exponencialmente.

Rust, Zig, V lang, Carbon, etc. no son los únicos autoproclamados "asesinos de C++". Jai también quiere formar parte de ese grupo.

Introducción a Jai

El lenguaje está en etapa de desarrollo. Aún no existe una versión definitiva, final.

Tomando esta declaración del blog de James Oswald:

"Jai se basa en la lista de quejas de Johnathan Blow sobre C++, escrita durante su etapa como desarrollador de juegos y motores de C++. Si bien Blow concibió Jai principalmente como un lenguaje para el desarrollo de videojuegos, no ha ocultado su opinión de que podría tener una aplicación más amplia fuera de este nicho".

Y continúa:

"Jai busca maximizar la alegría manteniendo el mismo rendimiento que C/C++. Si bien la discusión sobre la velocidad de compilación y la filosofía de Jai al respecto merece una publicación aparte, mencionaré brevemente que Jai supera con creces las velocidades de compilación actuales de C/C++ y probablemente seguirá haciéndolo (consulte esta publicación para un análisis aproximado de líneas/segundo de C/C++ en compiladores populares; el objetivo de Jai antes del lanzamiento es de 1 millón de líneas/segundo). Personalmente, tengo que compilar grandes aplicaciones de C/C++ desde cero con regularidad, así que soy un gran admirador".

¿Por qué existe?

Jai viene de la frustración de programar en C++.

Quienes hayan desarrollado en ese lenguaje (C++) sabrán que un proyecto real te puede llevar toda una vida no solo desarrollarlo sino también darle mantenimiento y actualización.

Lo que te puede llevar minutos hacer en lenguajes como Python u Go en C++ te llevará más tiempo. En pocas palabras, quiere hacer de la programación algo más sencillo sin la complejidad de C++ pero inspirándose
en el.

Enfoque

Jai es un lenguaje de más bajo nivel que Java o C# y no está orientado a objetos; un lenguaje compilado *ahead-of-time* (AOT) que cuenta con un sólido soporte para metaprogramación y ejecución de código en tiempo de compilación.

Características principales

• Una sintaxis sencilla y coherente, junto con una gran capacidad expresiva, que se traducen en una mayor productividad para el desarrollador y en más disfrute y diversión al programar. 
• Un compilador de altísima velocidad para hacer que el ciclo de desarrollo sea más productivo y agradable. ¡Se acabaron las pausas para el café mientras esperas a que termine la compilación! 
• Un rendimiento excelente, a la altura de C++ o incluso de C. 
• Seguridad en la ejecución y mensajes de error del compilador útiles, lo que reduce la necesidad de depuración.

Hola, mundo en Jai

holamundo.jai

#import "Basic";

main :: () {
   print("Hola, mundo desde Jai!");
}

#run main();

Un programa en este lenguaje no podría tener otra extensión que la de *.jai.

Para compilarlo se usa la herramienta de compilación (obvio):

$ jai holamundo.jai

Salida:

Hola, mundo desde Jai!

Hagamos un programa para sumar, restar, multiplicar y dividir.

operaciones.jai

#import "Basic";

sumar :: (a: int, b: int) -> int {
    return a + b;
}

restar :: (a: int, b: int) -> int {
    return a - b;
}


multiplicar :: (a: int, b: int) -> int {
    return a * b;
}

dividir :: (a: int, b: int) -> int {
    return a / b;
}


main :: () {
    x := 15;
    y := 27;
    resultado := sumar(x, y);
    print("La suma de ", x, " y ", y, " es: ", resultado);
    resultado := restar(x, y);
    print("La resta de ", x, " y ", y, " es: ", resultado);
    resultado := multiplicar(x, y);
    print("El producto de ", x, " y ", y, " es: ", resultado);
    resultado := dividir(x, y);
    print("La division de ", x, " y ", y, " es: ", resultado);
}

#run main();

Compilamos:

$ jai operaciones.jai

Salida:

La suma de 23 y 22 es: 45
La resta de 23 y 22 es: 1
El producto de 23 y 22 es: 506
La division de 23 y 22 es: 1

Si quieres saber más del lenguaje, consulta la guía: https://github.com/Ivo-Balbaert/The_Way_to_Jai

Jai se une a la larga lista de lenguajes que proeten ser los sucesores de C/C++. Con una compilación mucho más rápida y eficiente, tomando lo mejor de su(s) ancestro(s) y olvidando lo peor.

El lenguaje esta relativamente terminado y liberado para empezar a usarlo. Su enfoque es el desarrollo de videojuegos y hasta sistemas completos.

Seguiremos hablando de este y otros lenguajes de programación en siguientes entregas.

Enlaces:

https://jaiprogramming.com/
https://jamesoswald.dev/posts/jai-1/
https://inductive.no/jai/
https://programming-motherfucker.com/
Jonathan Blow on his programming language jai!
https://github.com/Ivo-Balbaert/The_Way_to_Jai