El lenguaje de programación C

El mítico lenguaje de programación C sigue siendo el lenguaje que definió todo. Y con todo nos referimos a todo lo referente a la informática y programación. En épocas que ya no existen más, el programador de computadoras, término y profesión que aún no se consideraba algo serio, tenía que cambiar la configuración de la máquina para que realizará otras operaciones. Enormes máquinas que ocupaban salas enteras apenas estaban diseñadas para ciertas tareas muy específicas.

Con la llegada de los programas almacenados está tarea reducía en gran medida ese esfuerzo. Sin embargo, los lenguajes de programación estaban muy ligados a la arquitectura de la máquina. Los programas no podían ser compartidos. Si querías un programa para cálculos vectoriales en tu máquina, tendrías que programarlo de acuerdo a la arquitectura de tu máquina (sic).

Es ahí cuando llegan los lenguajes de alto nivel. Lenguajes que están a un paso de los lenguajes máquinas y que no están ligados a ciertas arquitecturas.

Dennis Ritchie ideó un lenguaje de programmación al que denominó simplemente C. Un lenguaje de programación muy rápido, eficiente y tiene un control directo sobre el hardware y la memoria.

Un lenguaje que inspiró a otros como Java, C++, C#, entre otros más (y la lista crece). Un lenguaje intermedio entre el lenguaje máquina y los de alto nivel.

¿Qué es el lenguaje C?

"C es un lenguaje de programación de propósito general que ofrece como ventajas ecnonomía de expresión, control de flujo y estructuras de datos modernos y un conjunto rico de operadores. Además, C no es un lenguaje de muy alto nivel ni grande y no está especializado en alguna área especial de aplicación."

Puedes instalar el compilador gcc. Se puede instalar tanto en Mac OS, Linux y Windows.

Compilador gcc

Abrimos una terminal y listamos la versión:

$ gcc --version

Listamos la ayuda disponible:

$ gcc --help

Hola, mundo en C

Ejemplo 1. Escribamos el famoso programa del "Hola, mundo" en C.

holamundo.c

#include<stdio.h>

int main(){
 puts("Hola, mundo en C.");
 return 0;
}

Compilaremos el programa:

$ gcc -o holamundo.exe holamundo.c
$ ./holamundo.exe

Salida:

Hola, mundo en C.

Tipos en C

El lenguaje de programación C es un lenguaje estáticamente tipado pero con un sistema de tipos débil (o permisivo), lo que significa que requiere declarar el tipo de cada variable antes de usarla, pero permite conversiones implícitas automáticas entre tipos de datos compatibles.

Algunos de los tipos en este lenguaje son:

• char 
• int 
• byte 
• short 
• float 
• double

También permite definir tipos propios con typedef TipoDato NombreNuevaVaariable.

Como en muchos otros lenguajes no aplica el dicho de "Una variable es una variable". Un número entero deberá ser declarado con tipo int, y su valor es entero, un número con coma flotante (float) causará un error de compilación.

Miremos un ejemplo de conversión implícita:

#include<stdio.h>

int main(){
 int numero = 45;
 float numero_float = (float) numero;
 printf("Numero int = %d\n", numero);
 printf("Numero float = %.2f\n", numero_float);
 printf("Casteo = %d\n", (int) numero_float);
 return 0;
}

Esto también lo podemos observar en lenguajes modernos como Java o C#.

Programación modular

Un módulo se considera como una colección de paquetes y sus dependencias. En C los proyectos pueden estar divididos por módulos. Un programa puede tener cierta dependencia de archivos externos o dentro de su mismo ámbito. Es usual ver proyecto C con archivos de encabezados (*.h) y su implementación así como programas tipo "main" quienes son los encargados de realizar las operaciones principales.

Esto se puede observar en lenguajes como Java, C#, Python, etc.

Punteros y asignación dinámica de memoria

En C debemos tener cuidado con los punteros. Estos nos sirven para almacenar y manipular direcciones de memoria de la computadora, en lugar de guardar un valor directo (como un número o un texto). Un mal uso puede causar daños al programa o incluso a nuestra máquina.

También hay que tener cuidado con el mecanismo de asignación dinámica de memoria, el cual se usa para reservar espacio en la memoria RAM mientras el programa se está ejecutando (en tiempo de ejecución), en lugar de definirlo de forma fija cuando se compila.

Ambas "técnicas" son indispensables en el lenguaje, no son una opción aunque así pareciera. Conforme un programa se hace más grande y complejo se verán las ventajas de esto.

En próximas entregas veremos más sobre este lenguaje.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/06/el-lenguaje-de-programacion-d.html
https://es.wikipedia.org/wiki/C_(lenguaje_de_programaci%C3%B3n)
https://www.mingw-w64.org/
https://sourceware.org/cygwin/

El lenguaje de programación Go

Go es un lenguaje que ha ido cobrando algo de popularidad actualmente. Al igual que muchos este promete resolver todos los problemas de la computación.

Los desarrolladores empiezan a conocer las bondades que ofrece y promete. Crear microservicios y complejos sistemas concurrentes tolerantes a fallos ya es una realidad.

Desarrolladores que usan los lenguajes de programación habituales como C, C++, C#, Java, Python y hasta Kotlin ven como este lenguaje permite hacer cosas complicadas de una manera más accesible.

Empresas del sector financiero, educativo y otros rubros migran sus desarrollos hechos en PHP, C# y Java, por mencionar algunos lenguajes, a este poderoso lenguaje.

Este lenguaje esta basado en una arquitectura modular similar a los que se hace con otros lenguajes.

Un poderoso y concurrente lenguaje: Go

Al igual que C, es un lenguaje compilado. Permite la programación concurrente como Rust o Erlang/Elixir. En este lenguaje los tipos de datos son importantes.

Go es un lenguaje en el que si importas algo y no lo usas en el código, automáticamente lo descartará. Si defines un variable y no la usas, el compilador de Go te lo dirá.

Contrario al compilador de Java o C que ya compilado y ejecutado tu programa tendrá algunos errores y tú dirás "¿por qué no me avisaron que no estoy declarando tal o cual valor y no uso la variable "x" o "z" y me dejaste ejecutar?". Esto obliga al desarrollador a crear un mejor código.

Creando un proyecto Go

Hay dos formas para crear proyectos con Go:

• La clásica. 
• Con Go-Blueprint.

Crear un proyecto Go (la forma clásica)

Crearemos el clásico "Hola, mundo". Para ello crearemos el directorio y nos ubicaremos en el:

$ mkdir holamundo
$ cd holamundo

Iniciaremos un módulo (colección de paquetes y sus dependencias):

$ go mod init example.com\holamundo

Esto nos creará el módulo ``go.mod``. Ahora crearemos el ``main.go``:

package main

import "fmt"

func main() {
  fmt.Println("¡Hola, mundo en Go!")
}

La estructura de nuestro proyecto lucirá así:

holamundo/
   go.mod
   main.go

Ejecutamos:

$ go run main.go

Salida:

¡Hola, mundo en Go!

Continuamos con la segunda forma.

Crear proyecto con go-blueprint

Go-Blueprint,llanamente, es una herramienta que nos permite crear proyectos con Go. Desde la línea de comandos podremos armar un proyecto Go, además de agregarle funcionalidades. Como el hecho de integrar, por ejemplo, el framework Fiber, Gin, Gorilla/mux, configuración Docker, conexión a PostgeSQL a nuestro proyecto, entre otras cosas más.

Instalamos la herramienta:

$ go install github.com/melkeydev/go-blueprint@latest

Creamos un proyecto. Nos ubicaremos en un directorio y tecleamos desde la línea de comandos esta instrucción:

$ go-blueprint create --name hola-mundo

Nos ubicamos en el directorio creado:

$ cd hola-mundo

La estructura del proyecto lucirá así:

hola-mundo/
   .air.toml
   .env
   .gitignore
   cmd
   go.mod
   go.sum
   internal
   Makefile
   README.md

Editamos el programa principal ``cmd\api\main.go``:

package main

import "fmt"

func main() {
   fmt.Println("¡Hola, mundo con Go-Blueprint!")
}

Ejecutamos:

$ go run cmd\api\main.go

Salida:

¡Hola, mundo con Go-Blueprint!

Go-Blueprint es muy útil para quienes ya han trabajado con proyectos Go. No es recomendable para quienes apenas comienzan.

Quienes han trabajado con C encontrarán en este lenguaje algo similar. No es de sobra que uno de los co-creadores de C, Ken Thompson, también estuvo involucrado en su desarrollo. Tomando mucha inspiración de C; tomando lo mejor y olvidando lo peor.

Continuaremos hablando del lenguaje en próximas entregas.

Enlaces:

https://go.dev/
https://alquimistadecodigo.blogspot.com/2026/04/creando-proyectos-go-con-go-blueprint.html
https://alquimistadecodigo.blogspot.com/2025/12/creando-proyectos-con-go.html

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